DEV Community: Nick Langat

Beware of recursive signals in Django

Nick Langat — Thu, 13 Jun 2024 10:34:41 +0000

Quite recently, I was working on a backend project written in Django and I had defined the following models:



class Order(BaseModel):
    class Status(models.TextChoices):
        COMPLETE = "Complete"
        PENDING = "Pending"
        CANCELLED = "Cancelled"

    created_by = models.ForeignKey(
        User, on_delete=models.CASCADE, related_name="orders", null=True, blank=True
    )
    vendor = models.ForeignKey(
        Vendor,
        on_delete=models.CASCADE,
        related_name="vendor_orders",
        null=True,
        blank=True,
    )
    order_number = models.CharField(max_length=255, unique=True, blank=True, null=True)
    status = models.CharField(
        max_length=255, choices=Status.choices, default=Status.PENDING
    )
    notes = models.TextField(null=True, blank=True)
    email_sent = models.BooleanField(default=False)

    def save(self, *args, **kwargs):
        if not self.order_number or self.order_number == "":
            self.order_number = self.generate_unique_order_number()
        super().save(*args, **kwargs)

    def generate_unique_order_number(self):
        prefix = "ORD"
        suffix = "".join(random.choices(string.digits, k=5))
        return f"{prefix}-{suffix}"

    def __str__(self) -> str:
        return str(self.order_number)


class OrderItem(BaseModel):
    class Status(models.TextChoices):
        RECEIVED = "Received"
        PENDING = "Pending"

    order = models.ForeignKey(Order, on_delete=models.CASCADE, related_name="items")
    product = models.ForeignKey(
        Product, on_delete=models.CASCADE, related_name="product_items"
    )
    status = models.CharField(
        max_length=255, choices=Status.choices, default=Status.PENDING
    )
    price = models.DecimalField(max_digits=9, decimal_places=2)
    quantity = models.IntegerField(default=1)
    total = models.GeneratedField(
        expression=F("quantity") * F("price"),
        output_field=models.FloatField(),
        db_persist=True,
    )

    def __str__(self) -> str:
        return f"{self.order.order_number} - {self.product.name} - {self.total}"

TASK DEFINITION

The task at hand is to automatically update an Order status once all related OrderItems instances have been marked as Received.
To achieve this, we are going to tap into the almighty Django signals that ships out of the box.
So the first step is to create a signals.py file in our app folder:



touch core/signals.py

And register it in the core/apps.py file as so:



from django.apps import AppConfig


class CoreConfig(AppConfig):
    default_auto_field = "django.db.models.BigAutoField"
    name = "core"

    def ready(self):
        from .import signals

Once that is out of the way we can start by writing the signal function that will ensure all an order item is marked as complete once all orderitems are updated as received.
The function for that looks like:



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

from .models import Order, OrderItem

@receiver(post_save, sender=OrderItem)
def update_order_status(sender, instance, **kwargs):
    order = instance.order
    if order.items.filter(status=OrderItem.Status.PENDING).exists():
        if order.status == Order.Status.COMPLETE:
            order.status = Order.Status.PENDING
            order.save()
        return
    # If all items are received, update the status of the order to Complete
    order.status = Order.Status.COMPLETE
    order.save()

So basically when an OrderItem is updated, our signal checks if the Order associated to that OrderItem has any OrderItem with a status of Pending which should mean that not all related OrderItem instances have been received.
If that is the case the signal checks if the Order status is set to Complete. If that is the case, it reverts the status to Pending.
If all OrderItem instances have been received, i.e status is Received, it is time to mark that Order as complete.
And that works okay after I run the tests.

SECOND TASK DEFINITION

The reverse is true, if an Order gets marked as Complete, our backend should mark all related OrderItem instances as Received. This calls for another signal function to do that right?
I have written it and it looks like:



@receiver(post_save, sender=Order)
def mark_order_items_received(sender, instance, **kwargs):
    if instance.status == Order.Status.COMPLETE:
        order_items = instance.items.all()
        for order_item in order_items:
            order_item.status = OrderItem.Status.RECEIVED
            order_item.save()

So what it does is to check, upon saving, if an Order is set to Complete and if that is the case it loops through all related OrderItem instances, setting them to Received.
However this causes an infinite execution loop since we have another signal that listens on OrderItem upon saving so our signals will recursively execute and Django will show the following screen.

That seems to spoil our fun little party :(
I had to do some research and even ended upon consulting with ChatGPT so that I can get a way out. After a number of iterations, I learnt that we can also connect and disconnect from signal at will!
This looked like it would solve this whole recursive mess. So armed with this new knowledge, I made the following code edits to toggle the signals on and off.



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

from .models import Order, OrderItem


# Disable signal during certain operations to prevent recursion
def disable_signals():
    post_save.disconnect(update_order_status, sender=OrderItem)
    post_save.disconnect(mark_order_items_received, sender=Order)


def enable_signals():
    post_save.connect(update_order_status, sender=OrderItem)
    post_save.connect(mark_order_items_received, sender=Order)


@receiver(post_save, sender=OrderItem)
def update_order_status(sender, instance, **kwargs):
    order = instance.order
    if order.items.filter(status=OrderItem.Status.PENDING).exists():
        if order.status == Order.Status.COMPLETE:
            order.status = Order.Status.PENDING
            order.save()
        return
    # If all items are received, update the status of the order to Complete
    order.status = Order.Status.COMPLETE
    order.save()


@receiver(post_save, sender=Order)
def mark_order_items_received(sender, instance, **kwargs):
    if instance.status == Order.Status.COMPLETE:
        # Disable signal to prevent recursion
        disable_signals()
        order_items = instance.items.all()
        for order_item in order_items:
            order_item.status = OrderItem.Status.RECEIVED
            order_item.save()
        # Enable signal after performing the operation
        enable_signals()

In this updated code,I have defined two methods:



# Disable signal during certain operations to prevent recursion
def disable_signals():
    post_save.disconnect(update_order_status, sender=OrderItem)
    post_save.disconnect(mark_order_items_received, sender=Order)

Which essentially toggles of the two signals functions.



def enable_signals():
    post_save.connect(update_order_status, sender=OrderItem)
    post_save.connect(mark_order_items_received, sender=Order)

Which turns them back on.

Since the problem spawned from the second function, that is where I will be placing the toggle functions. Only if an Order status is Complete. The rest of the code remains the same.
And as predicted, this solution fixed the infinite loop of execution that I was facing before :).
Before moving on to the next thing, lest I forget I decided to document my experience for posterity haha😂.
See you on the next one.

ACID properties of a database system.

Nick Langat — Sun, 14 Apr 2024 05:43:09 +0000

This is a quick refresher on the acid properties of database system.
ACID stands for:

Atomicity
Consistency
Isolation
Durability Let's go over each one in detail.

ATOMICITY

This ensures that if a database transaction fails or one of its queries fails, then the whole transaction should fail and the database will be reverted to its previous state.

CONSISTENCY

This ensures that a database is in a valid state after a given transaction as per the constraints enabled in the database table.

ISOLATION

This ensures that concurrent transactions will result in the same results in the database if the same set of transactions were executed sequentially.

DURABILITY

This ensures that once a transaction has been committed to the database successfully, it will always be available irrespective of a catastrophic event such as a power cut or network failure.

Exploring Python's Map Built in

Nick Langat — Sun, 14 Apr 2024 05:42:01 +0000

This article first appeared on my personal blog here.

Introduction.

Python's standard library comes with a very useful built-in method called map() that we will take a tour of in this article.

By way of functionality, let's think of the map function this way:
It takes a function as its first argument and an iterable as second and then it applies the function to each member of the iterable in question.

That's the top level overview of the map built-in.

Now let's look at a few data problems, how we would transform them without map and then how we would transform them using map. Sounds good? Let's dive in.

Sample Problem:

Supposing you have a string of words like below:

title = "uses of strings in python"

Then you are asked to transform each word and capitalize only the first letter such that you end up with:

title = "Uses Of Strings In Python"

Without using map(), we can do something like:

title = "uses of strings in python"

title_list = title.split()
new_title = ""
for word in title_list:
    new_title  += f" {word.capitalize()}"

print(new_title)
#Uses Of Strings In Python

Which works, no problem. However, map()is well suited for such classic problems and we can leverage its power here. If you recall, map() takes a function and an iterable and returns a generator object having applied the function to all members of the iterable. With this in mind, we will follow the approach listed below:

We start by converting the string of words into a list by calling list.split().

We then apply str.capitalize() to each word in our list above. This will be our function.

We then call map() supplying our custom function and list above.
We then turn the generator object into a list.
We then call list.join() to get back our string of words.

The code for the above process will look like:

title_list = title.split()

new_title = " ".join(list(map(str.capitalize, title_list)))

print(new_title)
# Uses Of Strings In Python

Alternatively, you can use lambda() function to achieve the same effect, thus:

title_list = title.split()

new_title = " ".join(list(map(lambda x: x.capitalize(), title_list)))

print(new_title)
# Uses Of Strings In Python

It is also possible to have a user defined function then pass it to map() and it will give the same result. Consider:

def capitalize_word(word):
    return word.capitalize()

title_list = title.split()

new_title = " ".join(list(map(capitalize_word, title_list)))

print(new_title)
# Uses Of Strings In Python

Recap

In this article, we learnt what the map() does in Python from a high level point of view. We then saw an example problem where we put map() to use. Some key take aways here include:

map() takes a function and an iterable or iterables and then applies the function to each member of the iterable.
map() returns a map object which is a generator object. This can then be made into an iterable by applying the list().
map() works well with lambda(), other Python built-ins but can also accept a user defined function as its first argument.

Thank you for following this article to the end. I'll see you on the next one!

Building a shopping cart using Django Rest Framework

Nick Langat — Wed, 30 Aug 2023 14:29:44 +0000

Hey there and welcome to yet another article where I will walk you through an exciting concept which is an integral piece of most, if not all, e-commerce websites and applications.
The shopping cart or basket is very crucial in that it allows customers to pick the products they want to purchase akin to real life where we use a trolley or a basket to hold the various items we would like to purchase. Similarly, we accomplish the same task virtually using a shopping cart.

This tutorial aims to walk you through a step by step process of building such shopping cart logic while leveraging the power of Django and Django Rest Framework. Without further do let's dive in, shall we?

PROJECT SET UP

We will start by navigating to a folder on our workspace where we will create the project folder. For me, that is the Desktop folder, so open a terminal window and navigate to that folder:



cd desktop



mkdir drf_shopping_cart && cd drf_shopping_cart

Above, we are navigating into the desktop folder on our machine and then creating a folder called drf_shopping_cart and then navigating into it as well. Next let's issue the following commands which I explain shortly:



virtualenv env



source env/bin/activate



pip install django djangorestframework pillow

Here, we are creating a virtual environment to isolate our project's dependencies from the system wide configurations and settings and then we activate it and finally install our two main dependencies that is Django and DRF and the third dependency Pillow that is used for image processing in Python.
With those out of the way, issue the following commands which I explain in a bit:



django-admin startproject mysite .



python manage.py startapp cart

So the first command is used to create a new project and then the startapp command is used to create a new app inside our project. The cart app is where we shall spend a lot of our time writing code. The next vital step is to add our newly created cart app alongside DRF to the list of installed apps in the settings.py so go ahead and add it like so:



INSTALLED_APPS = [
    ....
    'cart',
    'rest_framework',
]

SETTING UP THE MODELS

Now if you think about it, we need a database table that will contain product information like name, price, image e.t.c. We can achieve that by using a Django model such that we will write Python code as a class and this will be translated to an SQL table thanks to the built-in Django ORM.
Head over to cart/models.py and add the following code:



from django.db import models

class Product(models.Model):
    name = models.CharField(max_length=150)
    description = models.TextField(blank=True)
    price = models.DecimalField(max_digits=10, decimal_places=2)
    image = models.ImageField(upload_to='products/%Y/%m/%d', blank=True)
    is_available = models.BooleanField(default=True)
    created_at = models.DateTimeField(auto_now_add=True)
    modified_at = models.DateTimeField(auto_now=True)

    def __str__(self) -> str:
        return str(self.name)

There we have defined a few table fields but feel free to add more as you see fit. To make sure that our database has this captured, we need to run the following commands to sync apply the changes:



python makemigrations && python manage.py migrate

At this point our database is ready.
Now, because we will handle product images we need to add a few more settings so that we do not run into errors and frustrations. First up open mysite/settings.py file and at the bottom add the following:



import os

MEDIA_ROOT = os.path.join(BASE_DIR, 'media')
MEDIA_URL = '/media/'

We are setting the MEDIA_ROOT, that is the absolute path to the directory where our application will serve the images from
and then we are then setting MEDIA_URL which is the url that will handle the images served from media root.

Next open mysite/urls.py and add the following code:



#...
from django.conf.urls.static import static
from django.conf import settings

urlpatterns = [
    #...
]

if settings.DEBUG:
    urlpatterns += static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)

At this point we are ready to move to the next chapter.

POPULATING THE DATABASE WITH PRODUCTS

Now we need to populate the database table for products with some data that we can use to test the shopping cart functionality.
We will need to create an endpoint that allows us to create and list products and to achieve this, we will create a serializer class to convert complex data types to native Python equivalents that can then be rendered as JSON.
Next we will create a view that will allow us to write into and read from the database.

Inside the cart folder create a file called serializers.py and add the following code:



from rest_framework import serializers
from .models import Product

class ProductSerializer(serializers.ModelSerializer):
    class Meta:
        model = Product
        fields = "__all__"

Next open up cart/views.py and add the following code:



from rest_framework.views import APIView
from rest_framework import status
from rest_framework.response import Response
from .serializers import ProductSerializer
from .models import Product

class ProductAPI(APIView):
    """
    Single API to handle product operations
    """
    serializer_class = ProductSerializer

    def get(self, request, format=None):
        qs = Product.objects.all()

        return Response(
            {"data": self.serializer_class(qs, many=True).data}, 
            status=status.HTTP_200_OK
            )

    def post(self, request, *args, **kwargs):
        serializer = self.serializer_class(data=request.data)
        serializer.is_valid(raise_exception=True)
        serializer.save()

        return Response(
            serializer.data, 
            status=status.HTTP_201_CREATED
            )

We have created a single endpoint that will allow us to perform a GET request to retrieve all products in the database and a POST request to save new products into the database.
Next open mysite/urls.py and add the following code:



#...
from cart.views import ProductAPI

urlpatterns = [
    #...
    path('products', ProductAPI.as_view(), name='products'),

]
#...

We are ready to add new products to the database so spin up the server by:



python manage.py runserver

Visit http://localhost:8000/products and add a couple of products.

BUILDING THE SHOPPING CART

At this point we already have a product catalog and now we need to implement a shopping cart that allows customers to add any product they want while browsing the online shop.
The shopping cart should store whatever products it has temporarily while the customers browse the site until they place an order.

For this, we will make use of Django's session framework to persist the cart and keep it in session till an order is placed or the session expires.

Django's session framework supports both anonymous and user sessions and the data stored is unique to each site visitor. When we created the project, Django added a session middleware django.contrib.sessions.middleware.SessionMiddleware to manage all sessions in the project. This middleware avails the current session in the request object as a dictionary thus we can access it by calling request.session and it is JSON serializable.

Enough literature, lets's write some code :). Here is what we are about to do:

Create a cart service to handle cart operations
Create an API endpoint that calls the cart service
Test every cart operation

As mentioned above we need to create a service to put the logic for the cart. Inside the cart folder create a file called service.py and add the following code:




from decimal import Decimal

from django.conf import settings

from .serializers import ProductSerializer
from .models import Product


class Cart:
    def __init__(self, request):
        """
        initialize the cart
        """
        self.session = request.session
        cart = self.session.get(settings.CART_SESSION_ID)
        if not cart:
            # save an empty cart in session
            cart = self.session[settings.CART_SESSION_ID] = {}
        self.cart = cart

    def save(self):
        self.session.modified = True

    def add(self, product, quantity=1, overide_quantity=False):
        """
        Add product to the cart or update its quantity
        """

        product_id = str(product["id"])
        if product_id not in self.cart:
            self.cart[product_id] = {
                "quantity": 0,
                "price": str(product["price"])
            }
        if overide_quantity:
            self.cart[product_id]["quantity"] = quantity
        else:
            self.cart[product_id]["quantity"] += quantity
        self.save()

    def remove(self, product):
        """
        Remove a product from the cart
        """
        product_id = str(product["id"])

        if product_id in self.cart:
            del self.cart[product_id]
            self.save()

    def __iter__(self):
        """
        Loop through cart items and fetch the products from the database
        """
        product_ids = self.cart.keys()
        products = Product.objects.filter(id__in=product_ids)
        cart = self.cart.copy()
        for product in products:
            cart[str(product.id)]["product"] = ProductSerializer(product).data
        for item in cart.values():
            item["price"] = Decimal(item["price"]) 
            item["total_price"] = item["price"] * item["quantity"]
            yield item

    def __len__(self):
        """
        Count all items in the cart
        """
        return sum(item["quantity"] for item in self.cart.values())

    def get_total_price(self):
        return sum(Decimal(item["price"]) * item["quantity"] for item in self.cart.values())

    def clear(self):
        # remove cart from session
        del self.session[settings.CART_SESSION_ID]
        self.save()

Now let's go through the code above since a lot is happening therein.
We defined a Cart class that allows us to manage the shopping cart.

The __init__ method is our constructor and requires a request object to initialise the cart. We also store the current session making it accessible to the other methods of the cart class. As seen, we try to get the cart from the current session and if it is missing we create an empty cart by setting an empty dictionary in the session.

The add method is our next one and this is used to add products to the cart or update their quantity. It takes product, quantity, override_quantity as parameteres. The product ID acts as the key to the dictionary while the quantity and price figures become the value of the dictionary.

The save method simply marks the session as modified and thus Django knows that the session changed and needs to be saved

The remove method does exactly that, removes a given product from the cart. It also calls the save method to make sure everything is saved.

We then defined an __iter__ method which allows us to loop over cart's items and access the related product objects. Here we fetch product instances present in the cart. We will make use of this in our view.

The __len__ method returns the number of total items in the cart.

The get_total_price method calculates the total cost of items in the cart.

Last but not least, the clear method removes the cart object from the session as it deletes the entire dictionary before calling the save method.

Finally we add the following setting to the mysite/settings.py file.



CART_SESSION_ID = 'cart

With all that in place, our Cart class is ready to manage shopping carts.

CREATING SHOPPING CART API VIEWS

Well, we have a Cart class to manage the cart, we now need to create API endpoints to list, add, update, remove items and clear the cart.
With this in mind, let's create the views. Open cart/views.py and add the following code:



class CartAPI(APIView):
    """
    Single API to handle cart operations
    """
    def get(self, request, format=None):
        cart = Cart(request)

        return Response(
            {"data": list(cart.__iter__()), 
            "cart_total_price": cart.get_total_price()},
            status=status.HTTP_200_OK
            )

    def post(self, request, **kwargs):
        cart = Cart(request)

        if "remove" in request.data:
            product = request.data["product"]
            cart.remove(product)

        elif "clear" in request.data:
            cart.clear()

        else:
            product = request.data
            cart.add(
                    product=product["product"],
                    quantity=product["quantity"],
                    overide_quantity=product["overide_quantity"] if "overide_quantity" in product else False
                )

        return Response(
            {"message": "cart updated"},
            status=status.HTTP_202_ACCEPTED)

A lot is going on there so let's break it down. We are sub classing Rest framework's APIView and defining two http methods.

In the get method we send a GET request and initialise a cart object then we call its __iter__ method that will give us back a generator object. We then call the built in list to get a list that we then serialize as part of our response. Also we are returning the cart's total by calling get_total_price.

In the post method we send a POST request and then initialise an instance of the cart passing the request and then we check for the presence of a few things in the request payload.

We check whether we have a key named remove in the payload and if it exists then we call the remove() of the cart passing in the product from the payload.

We then check whether we have a key named clear in the payload and if it exists then we call the clear() of the cart to remove it from the current session.
If we don't have those two keys then we call the add() of the cart passing in the product, quantity and whether or not to override quantity.

At the end of the day we send back a response with a message and status but we can do more than that, be creative. We just have one last step before we test our logic.
Open mysite/urls.py and add the following code to it:



#...
from cart.views import CartAPI

urlpatterns = [
    #...
    path('cart', CartAPI.as_view(), name='cart'),
    #...
]
#...

LET'S TEST THE CART

Ensure that the server is still running. Head over to the cart's url that is http://localhost:8000/cart. Let's make a post call with the follwoing payload:



{
  "product": {
            "id": 1,
            "name": "Macbook Pro",
            "description": "Our most powerful laptops, MacBook Pros are supercharged by M1 and M2 chips. Featuring Magic Keyboard, Touch ID, and brilliant Retina display.",
            "price": "1800.00",
            "image": "/products/2023/08/30/sp809-mbp16touch-silver-2019.jpeg",
            "is_available": true,
            "created_at": "2023-08-30T11:58:54.476688Z",
            "modified_at": "2023-08-30T11:58:54.476720Z"
        },
  "quantity": 5
}

Now on get request we should see the following screen to show that the addition worked.

To remove a specific product from the cart the payload to send would look like:



{
  "product": {
            "id": 1,
            "name": "Macbook Pro",
            "description": "Our most powerful laptops, MacBook Pros are supercharged by M1 and M2 chips. Featuring Magic Keyboard, Touch ID, and brilliant Retina display.",
            "price": "1800.00",
            "image": "/products/2023/08/30/sp809-mbp16touch-silver-2019.jpeg",
            "is_available": true,
            "created_at": "2023-08-30T11:58:54.476688Z",
            "modified_at": "2023-08-30T11:58:54.476720Z"
        },
  "remove": true
}

And to clear the cart the payload would be simply:



{
  "clear": true
}

Go ahead and test them out and see what you end up :)

THAT"S A WRAP

Yes that's a wrap! If you made it to the end of the tutorial then a big hugops to you. Thank you for taking time to read and follow along and I hope you learnt a thing or two that will help progress your coding journey.
If you have any thoughts, questions etc then leave them down below.

I am also looking for my next role so if your team is hiring or know anyone who is, then I'll be much obliged if I get a referral.

I am available via Twitter or my linkedin or my website and my email is nicksonlangat95@gmail.com.

The code used in this tutorial can be found here.
Bye for now and see you on the next one. Cheers 🥂

How to deploy a FastAPI app to AWS EC2 server.

Nick Langat — Tue, 07 Jun 2022 08:10:51 +0000

Hello fellow tech enthusiasts Nick here. It's been a while since I posted an article but hey here I am and with a fresh one.
So a time comes when you have built an Python application using FastAPI and after testing it locally and pleased with its functionality, you wanna take it to the web and make it publicly accessible.
LOCAL SETUP
In this article we will bootstrap a simple application then commit it to Github and finally deploy it to an AWS EC2 instance.
We start by creating a local workspace on our machine so navigate to desktop and create a folder hello_fastapi and open it using your code editor.
Next let's create a virtual environment to hold our dependencies.

virtualenv env

Then activate it using

env/Scripts/activate on windows
source env/bin/activate on linux/unix

Now that we have our environment set up let's install what we need.

pip install fastapi uvicorn gunicorn psycopg2-binary

You may add the deps depending on what your project will need in order to work.
With the deps installed we then create a file that will hold them all.

pip freeze > requirements.txt

Next create a file called main.py at the root of the project and add the following code to it.

import uvicorn

if __name__ == "__main__":
    uvicorn.run("app:app", host="0.0.0.0", port=8000, reload=True)

Then create another file at the root called app.py with the following code:

from fastapi import FastAPI
from fastapi.middleware.cors import CORSMiddleware

app = FastAPI()

origins = ["*"]

app.add_middleware(
    CORSMiddleware,
    allow_origins=origins,
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

@app.get("/", tags=["Root"])
async def read_root():
    return {"message": "Welcome to the API!"}

Let's test the app to see if it is running well on our local browser:
Run the server by:

uvicorn  app:app --reload

Next visit your browser at localhost and you should get greeted by

{"message":"Welcome to bills API!"}

If everything works then we have a working app and we can procced to the next section.

VERSION CONTROL
While still in the root of the project we can issue the follwoing commands to push our code to Github:

git init
git add .
git commit -m 'initial'
git remote add origin <REMOTE URL HERE>
git push -u origin master

If all goes well then you should have your code uploaded and stored on a Github repo. We are safe to proceed to the next step.
DEPLOYING TO AWS EC2
The assumption am making here is that you have an AWS account and have created a free tier EC2 server running on Ubuntu. Feel free to checkout docs on how to do that here.
These steps will work on any Ubuntu machine though so if you are on DigitalOcean, Linode or Oracle it should work well.
Let's ssh into our remote machine then:

ssh -i 'example.pem' ubuntu@ec2-IP-ADDRESS.us-east-2.compute.amazonaws.com

Once you are inside the remote machine we need to install Python and NGINX.
Issue the following commands on the terminal:

sudo apt update
sudo apt install python3-pip python3-dev libpq-dev postgresql postgresql-contrib nginx curl
sudo -H pip3 install --upgrade pip

Next create a folder that will carry our files:

mkdir apiv1 && cd apiv1

Then create and activate a virtual environment like we did before.
After that initiate git inside the folder and pull your code from github.

git init
git remote add origin <REPO URL>
git pull origin master

Now we install our deps like so:

pip install -r requirements.txt

Deactivate the virtualenv after running the local server and ensuring no errors are reported.
Next up we need to bind our application to a gunicorn module that serves as an interface to your application, translating client requests from HTTP to Python calls that your application can process.
So we start by creating a socket file:

sudo nano /etc/systemd/system/gunicorn.socket

Add the following code to it:

[Unit]
Description=gunicorn socket

[Socket]
ListenStream=/run/gunicorn.sock

[Install]
WantedBy=sockets.target

Save and close that file. Next we create a service file:

sudo nano /etc/systemd/system/gunicorn.service

Add the following code to it:

[Unit]
Description=gunicorn daemon
Requires=gunicorn.socket
After=network.target

[Service]
User=ubuntu
Group=www-data
WorkingDirectory=/home/ubuntu/apiv1
ExecStart=/home/ubuntu/apiv1/env/bin/gunicorn \
          --access-logfile - \
          --workers 5 \
          --bind unix:/run/gunicorn.sock \
          --worker-class uvicorn.workers.UvicornWorker \
          app:app

[Install]
WantedBy=multi-user.target

Save and close as well.
Next start the Gunicorn socket:

sudo systemctl start gunicorn.socket

Then enable it by:

sudo systemctl enable gunicorn.socket

Now that Gunicorn is set up, next we’ll configure Nginx to pass traffic to the process.
Start by creating and opening a new server block in Nginx’s sites-available directory:

sudo nano /etc/nginx/sites-enabled/api

Add the following lines to it:

server {
    listen 80;
    server_name server_domain_or_IP;
    location / {
        proxy_pass http://unix:/run/gunicorn.sock;
    }
}

Save this file as well. Test that the config is okay by:

sudo nginx -t

If all is well then we need to restart the services so go aheda and:

sudo systemctl daemon-reload
sudo systemctl restart gunicorn
sudo systemctl restart nginx

One last step is to ensure that you have allowed HTTP access via port 80 on your instance's security group section. Do the same for port 443 if your app is served over HTTPS.
If all the above is done then go to your instance's public IP address or domain and hopefully you will see your app being displayed there.
WRAP UP
And that's it folks, if you made it here then a huge shoutout to you!
Today we built a simple Python app using FastAPI and deployed it to an EC2 Ubuntu server provided by AWS.
If you found this helpful the show some love by liking, commenting or sharing. You can also follow me on Twitter or visit my webite.
Thank you and till next time!

Upload multiple images to your Django app using Dropzone Js

Nick Langat — Wed, 18 Aug 2021 08:09:05 +0000

Hello guys it's been a minute! I was on a small break but now am back and in this tutorial we are going to learn how we can upload multiple images to a Django back end. By default the Django behavior is that you select a single image and upload it to the server then repeat which begs the question isn't that a time consuming and tedious process, say if we have 1000 images? It is.
Fortunately, there is a tool that can help us go around this problem, a JavaScript library called Dropzone . Let's not waste more seconds, let's get into it!

PROJECT SETUP

Let's quickly navigate to our desktop directory and bootstrap the back end.

cd ~/Desktop

mkdir django_dropzone && cd django_dropzone

virtualenv env

source env/bin/activate

pip install django

django-admin startproject mysite .

python manage.py startapp core

Next add core to the list of installed apps in settings.py.
While there also update the templates section as follows:

import os

'DIRS': [os.path.join(BASE_DIR, 'templates')],

Then also update the static settings like so:

STATIC_URL = '/static/'
if DEBUG:
    STATICFILES_DIRS = [os.path.join(BASE_DIR, 'static')]
else:
    STATIC_ROOT = os.path.join(BASE_DIR, 'static')

MEDIA_ROOT = os.path.join(BASE_DIR, 'media')
MEDIA_URL = '/media/'

IMAGE MODEL

We have set up our settings.py and it's good to go. Move to core/models.py and add the following code:

from django.db import models

# Create your models here.

class Image(models.Model):
    image=models.ImageField(upload_to='images/')
    date = models.DateTimeField( auto_now_add=True)

    class Meta:
        ordering=['-date']

    def __str__(self):
        return str(self.date)

Go ahead and makemigrations then migrate to apply the changes to the db.
Next we go the the views.py. Write the following code to it.

from django.shortcuts import render
from django.http import HttpResponse, JsonResponse
from .models import Image
# Create your views here.

def home(request):
    images=Image.objects.all()
    context={
        'images':images
    }
    return render(request, 'index.html', context)

def file_upload(request):
    if request.method == 'POST':
        my_file=request.FILES.get('file')
        Image.objects.create(image=my_file)
        return HttpResponse('')
    return JsonResponse({'post':'fasle'})

Next create core/urls.py and add the following code to it:

from django.urls import path
from . import views
urlpatterns = [
    path('', views.home, name='home'),
    path('upload/', views.file_upload),
]

To finalise the Python part, add the following code to the project's urls.py

rom django.contrib import admin
from django.urls import path, include
from django.conf import settings
from django.conf.urls.static import static

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include('core.urls')),
]

if settings.DEBUG:
    urlpatterns += static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)

DROPZONE SETUP

We are done with the logic let's do the UI stuff. Create a folder called static and in it create two files:

touch static/main.js

touch static/style.css

Add the following code to main.js:

Dropzone.autoDiscover=false;
const myDropzone= new Dropzone('#my-dropzone',{
    url:'upload/',
    maxFiles:5,
    maxFilesize:2,
    acceptedFiles:'.jpg',
})

And the following to style.css:

body {
    background-color: #f8f8f8 !important;
}

.dz {
    border: dashed !important;
    background-color: #ccc !important;
    border-radius: 10px !important;
}

.dz:hover {
    background-color: aliceblue !important;
}

Next create a folder called templates and in it create two files:

touch templates/base.html

touch templates/index.html

Add the following code to base.html

{% load static %}
<!doctype html>
<html lang="en">
  <head>
    <!-- Required meta tags -->
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">

    <!-- Bootstrap CSS -->
    <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.5.2/css/bootstrap.min.css">
    <!-- Font awesome -->
    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/4.7.0/css/font-awesome.min.css">
    <!-- custom css & js -->
    <link rel="stylesheet" href="{% static 'style.css' %}">
    <script src="{% static 'main.js' %}" defer></script>

    <script src="https://rawgit.com/enyo/dropzone/master/dist/dropzone.js"></script>
    <link rel="stylesheet" href="https://rawgit.com/enyo/dropzone/master/dist/dropzone.css">


    <title>Drag and Drop Django| {% block title %}{% endblock title %}</title>
  </head>
  <body>
    <div class="container mt-3">
        {% block content %}
        {% endblock content %}
    </div>

    <!-- Optional JavaScript -->
    <!-- jQuery first, then Popper.js, then Bootstrap JS -->
    <script src="https://code.jquery.com/jquery-3.5.1.min.js"></script>
    <script src="https://cdn.jsdelivr.net/npm/popper.js@1.16.1/dist/umd/popper.min.js"></script>
    <script src="https://stackpath.bootstrapcdn.com/bootstrap/4.5.2/js/bootstrap.min.js"></script>
  </body>
</html>

And the following to index.html:

{% extends 'base.html' %}

{%block content%}
<h6>UPLOAD MULTIPLE IMAGES NOW</h6>
<br>
<form enctype='multipart/form-data' action="upload/" method='POST' class="dropzone dz" id="my-dropzone" >
    {% csrf_token %}
    <div class="fallback">
      <input name="file" type="file" multiple />
    </div>
</form>
{%endblock%}

SPIN UP THE SERVER

Now go to the terminal and:

python manage.py runserver

Check the browser and upload images, be sure to select multiple.

and

MISSION SUCCESS

Yeah that should do it for this article. Thanks for keeping me company and coding along. You can grab the source code of this project here
You can connect with me on LinkedIn and on Twitter
Cheers and see you next time!

Access bus booking services using Django & AfricasTalking API

Nick Langat — Sun, 08 Aug 2021 13:27:43 +0000

I am very certain that each one of us has, in the past took a long journey and you had to find a vehicle that goes express without dropping you midway. Chances are you went to their booking office, acquired a ticket and then waited for your bus to arrive ,board it then take off. Notice that you had to manually go to the station, queue then get your flight ticket.

This is all fine given the circumstances but what if I told you that we could digitize this process of acquiring bus ticket such that you can book a bus while seated in your house and only have to go and start the journey when the time for your bus has come? We are going to see how.

In this post we are going use Django to create a USSD bus booking system where:

Users can query all buses in the system
Users can book a bus
Users can check the status of their flight
Users can cancel their flight
Users can report complains

The USSD service is made possible thanks to Africa'sTalking. We will use their sandbox environment to simulate a real life scenario of our application. Without further talk let's start!

PROJECT SETUP

Let's quicky create a new project:



mkdir django_ussd && cd django_ussd

virtualenv env

source env/bin/activate

pip install django

django-admin startproject mysite .

python manage.py startapp core

Next add core to the list of installed apps in settings.py.
Now let's create the following models to hold our data:



from django.db import models
# Create your models here.
class Bus(models.Model):
    number_plate=models.CharField(
        max_length=10
    )
    start=models.CharField(
        max_length=250
    )
    finish=models.CharField(
        max_length=250
    )
    price = models.FloatField()
    seats=models.IntegerField()
    is_available=models.BooleanField(
        default=True
    )
    def __str__(self) -> str:
        return self.number_plate

class Booking(models.Model):
    STATUS_CHOICES = [ 
    ("Awaiting departure", "Awaiting departure"),
    ("Journey complete", "Journey complete"),
    ("Cancelled", "Cancelled"),
    ]
    bus = models.ForeignKey(Bus, on_delete=models.CASCADE)
    customer = models.CharField(max_length = 150)
    seat=models.IntegerField(default=0)
    date = models.DateTimeField(auto_now_add=True)
    departure=models.DateTimeField(null=True, blank=True)
    status = models.CharField(
        max_length = 20,
        choices = STATUS_CHOICES,
        default = 'Awaiting departure'
        )
    def __str__(self) -> str:
        return self.customer

from django.contrib import admin
admin.site.register(Bus)
admin.site.register(Booking)

So our Bus class will have all details related to a given bus while Booking will store user tickets. Go ahead and makemigrations then migrate.
Create an admin user then go to the admin section and add a few buses that we will use for testing.
Next let's write our application logic. Open views.py and add the code below to it. If need be, by all means take a minute to go through it and understand. It is pretty straight forward.



import random
from datetime import datetime, timedelta
from core.models import Booking, Bus
from django.views.decorators.csrf import csrf_exempt
from django.http import HttpResponse

# Create your views here.
@csrf_exempt
def index(request):
    if request.method == 'POST':
        session_id = request.POST.get('sessionId')
        service_code = request.POST.get('serviceCode')
        phone_number = request.POST.get('phoneNumber')
        text = request.POST.get('text')

        response = ""

        if text == "":
            response = "CON Welcome! \n Which service would you like to access? \n"  
            response += "1. List all our buses  \n"
            response += "2. Check ticket status \n"
            response += "3. Book a bus seat \n"
            response += "4. Cancel a booking \n"
            response += "5. Report an issue"

         #User needs a list of all buses   
        elif text == "1":
            results=Bus.objects.all()
            for i in results:
                response += f"END {i}:{i.start}-{i.finish} @KSHS{i.price} \n \n"

        elif text == "2":
            response = "CON Choose an option \n"
            response += "1. All tickets \n"
            response += "2. Today active tickets"

         #Follow up
        elif text == '2*1':
            tickets=Booking.objects.filter(
                customer=phone_number
            )
            for tkt in tickets:
                response += f"END Ticket {tkt.id} on {tkt.departure:%Y-%m-%d %H:%M}"

         #Follow up
        elif text == '2*2':
            now = datetime.now()
            tickets=Booking.objects.filter(
                customer=phone_number,
                departure__date=now
            )
            if tickets:
                for tkt in tickets:
                    response += f"END Ticket {tkt.id} on {tkt.departure:%Y-%m-%d %H:%M}"
            response ='END No tickets found'

        #User wants to book a seat
        elif text == "3":
            response = "CON Okay, pick a route \n"
            response += "1. Kericho-Nairobi \n"
            response += "2. Kisumu-Eldoret \n"
            response += "3. Nakuru-Mombasa \n"
            response += "4. Narok-Naivasha "

        #Follow up
        elif text == '3*1' or '3*2' or '3*3' or '3*4':
            seat=random.randint(1,30)
            buses=Bus.objects.filter(is_available=True)
            buses=[bus for bus in buses]
            bus=random.choices(buses)
            for i in bus:
                bus=i
            departure=datetime.now() + timedelta(hours=1)
            new_booking=Booking.objects.create(
                bus=bus,
                customer=phone_number,
                seat=seat,
                departure=departure

            )
            response = f"END  Alright! Here is your booking info: \n TICKET NO {new_booking.id} \n Bus Number is {bus} \n Your seat number is {seat} \n Your bus leaves at {departure:%H:%M:%S}"  
        elif text == "4":
            response = "END Feature work in progress, check again soon"
        elif text == "5":
            response = "END Feature work in progress, check again soon"

        return HttpResponse(response)

With that figured out we can move on to create the route for it. Update the project urls.py like so:



from django.contrib import admin
from django.urls import path
from core import views

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', views.index),
]

And that should be all we need. Now the next part is to expose our application to the internet because AfricasTalking cannot find our localhost. A great tool for such is Ngrok . Follow its instructions to get installed on your machine if you haven't already.
To tunnel our app:



ngrok http 8000

Result:

Copy that https link we'll need it next up.

AFRICASTALKING SETUP

Log in to your AfricasTalking account then head over to the simulator section click on USSD part and click to create a new session. Now add the ngrok link that you created before to act as our callback. In case you need to know what a callback is, then here is a post. Now the form should be like shown below:

Save the form:

So for me, the app will be invoked by dialing *384*1827# yours may be a bit different but should work.

SIMULATING

We now have an application baked and we have configured our sandbox environment. Go ahead and launch the simulator then pick 'USSD' when the phone shows up. Enter your code, for me it is *384*1827#. The behavior should be:

Let's book a bus for instance:

Following prompts ends up returning a complete info including the time the bus leaves:

Go ahead and test all other options and see what they have to offer. Add your creativity to the code as well.

WRAP UP

If you are still here then hats off to you. Congratulations. In this tutorial we were solving a transport problem. We built a solution from scratch to help passengers book buses and access a range of related services offline via USSD. Thus whether on featured phones(Kabambe) or smartphone, they can have at it with no problem.
That is all I had for you guys. Let me know if you encounter an issue or have a suggestion in the comments below. Also if possible show some love to this post.
As usual you can follow me here or on Twitter for more awesome content.
Till next time, cheers!

Solving The Move Zeroes Challenge in Python, three approaches

Nick Langat — Wed, 04 Aug 2021 17:04:57 +0000

A while ago, my colleague and I were discussing a very interesting question on data structures and algorithms. This question is provided by LeetCode
Our thoughts were on the different ways we would try to arrive at the solution factoring in all constraints given. To give you a perspective, here is the problem statement:
Given an integer array nums, move all 0's to the end of it while maintaining the relative order of the non-zero elements.
Note that you must do this in-place without making a copy of the array.
So if we have a list of numbers like:

nums=[8,0,3,5,0,4]

We move all 0's to the end of it while retaining the non-zero numbers such that:

nums=[8,3,5,4,0,0]

The first solution which is not very optimal and would break the in place constraint would be to make a copy of the array and insert non-zero elements by:

nums=[8,0,3,5,0,4]
def move_zeroes():
  zeroes=[]
  non_zeroes=[]
  for i in nums:
    if i ==0:
      zeroes.append(i)
  for i in nums:
    if i !=0:
      non_zeroes.append(i)
  print(non_zeroes + zeroes)

That is a huge chunk so can we tidy it up a lil bit? Of course using list comprehensions such that:

def move_zeroes():
  pri nt([i for i in nums if i !=0]+[i for i in nums if i ==0])

But that wouldn't be the best solution since we need to use constant space and our loop here is disobeying that.
We can build up on what we already have and not use a for loop but swap intermediate elements while checking their values. We can achieve this by using two pointers i and j. i will be our slowest pointer while j the fastest.
Let's construct this logic bit by bit:

def move_zeroes():
  length=len(nums)
  # print(length)
  i=j=0

So we first get the length of our array and store it in a variable. Then we initialize our pointers and assign them to 0 to begin with. After that we can:

def move_zeroes():
  length=len(nums)
  # print(length)
  i=j=0
  while j < length:
    if nums[j]==0:
      j +=1
    else:
      nums[i],nums[j]=nums[j],nums[i]
      j +=1
      i +=1
  print(nums)

So we are going to keep track of j our fastest pointer. As long as it is within the length of our array:
1.We check its value if it is equal to zero. If it is we move the pointer position forward by 1.
2.If j is not zero then we swap j and i then move each of them forwards.

We then return our initial array.

If we run that logic the stats are:

Which is decent if anything is to go by.
Thanks for reading through and see you on the next one.

Schedule & send rent invoices to tenants at regular intervals using Django & AfricasTalking API

Nick Langat — Sun, 01 Aug 2021 10:15:13 +0000

THE PROBLEM

If you are a caretaker or a landlord of a rentals property, chances are every end of the month, you draft paper invoices and then walk door to door issuing each tenant with their specific invoice. Not only is this tedious and time consuming but also you risk walking to a tenant's door and finding that they are not in and you have to come again at a later time or the next day(s).
A hypothetical property, Kwetu Apartments is one such business that has hitherto been doing things this way and they have decided that it is time they embrace technology and become a digital first business by leveraging on automation tools to handle the otherwise daunting manual invoicing method.

THE SOLUTION

The owner of Kwetu Apartments approached our team of software developers and after lengthy talks, we decided to develop a portal for them that will:
1.Send text message reminders to tenants with invoice details every 30th of each month.
2.process rent payments using either card or mpesa and then update each tenant's status as either paid or not.
The portal will then send text messages to those who have not paid to remind them to make payments.
The assumption here is that we have already developed the logic to process tenants payments and now what we have to do is implement the logic to send text reminders every 30th each month. In case you need an article on payment processing then go through this post I wrote a few days back.

PROJECT SETUP

Create a new project and start a new app:

django-admin startproject tenants_project .

python manage.py startapp invoices

Remember to add invoices to the list of installed apps in tenants_project/settings.py
Let's quickly create a database class that will house all our tenants and their details:

from django.db import models

# Create your models here.
class Tenant(models.Model):
    name=models.CharField(max_length=250)
    phone=models.CharField(max_length=250)

    def __str__(self):
        return self.name

Go ahead and makemigrations then migrate. Register the model in admin.py. Also create a superuser, login to the admin section of the project and add a few tenant instances. After that we can begin sending them invoices messages every month!

AFRICASTALKING CONFIG

Stop the server but retain the virtual env. Install AfricasTalking helper library by:

pip  install africastalking

Now log in to their website. Click on 'Sandbox' and from the resulting dashboard click on 'Settings' then 'API Key'. Click to generate a new key which you will copy and store it safe as we are using it in a bit.

SCHEDULER LOGIC

We then move on to install a package that will help us with task scheduling. While still on terminal do this:

pip install apscheduler

Create a file within invoices called invoice_update.py and add the code below to it:

from .models import Tenant
import africastalking

# Initialize SDK
username = "sandbox"    
api_key = "YOUR SANDBOX API KEY" 
africastalking.initialize(username, api_key)

sms = africastalking.SMS

def send_reminders():
    tenants=Tenant.objects.all()
    for tenant in tenants:
        invoice_message=f'Hello, {tenant.name}, your rent payment of shs 10,000 is due on demand. Please plan to pay before 5th.'
        response =sms.send(invoice_message, [str(tenant.phone)]) 
        print(response)

Next, create another file within invoices called updater.py and add the code below to it:

from apscheduler.schedulers.background import BackgroundScheduler
from . import invoice_update

def start():
    scheduler = BackgroundScheduler()
    scheduler.add_job(invoice_update.send_reminders, 'interval', seconds=10)
    scheduler.start()

So here we are scheduling a reminder with invoice details for all the tenants in our database. For testing purposes we are running that task every ten seconds but in production we would put a cron job to run every 30th. Save that file then move to invoices/apps.py and update it like so:

from django.apps import AppConfig

class InvoicesConfig(AppConfig):
    default_auto_field = 'django.db.models.BigAutoField'
    name = 'invoices'

    def ready(self):
        from . import updater
        updater.start()

So every time our project boots, our scheduler runs in the background and does its thing.
Let's take it for a spin and see what's what:

python manage.py runserver

Head over to your AT Sandbox and launch it.
You will see an image like below:

Click on the SMS card and you will see:

Great, our tenants got the invoice messages as intended by Kwetu Apartments.

WRAP UP

In this article we have eliminated the need of Kwetu Apartment caretakers and landlords to draft paper invoices and then walk door to door delivering them to tenants. We developed a solution that is robust and scalable that can server as many users as possibles with minimal human input.
The code to this project can be found at my repo.

Thanks for reading and coding along. Go ahead and add creativity and share what you will come up with.
If you have any questions or comment then leave them below or on my Twitter.
Cheers and happy hacking!

Understanding different error types in Python

Nick Langat — Sat, 31 Jul 2021 07:05:41 +0000

If you are anything like me,you spend the better part of your day writing code but sometimes the code just will not execute the way you want it to and give you the desired results.This awkward situation is aptly captured by this quote: "Anything that can go wrong will go wrong" ~Murphy's Law.

See, in our capacities as software developers we are still humans and that means from time to time we will make mistakes. Now this mistakes can translate to different errors in our programs. In this article we are going to examine three common errors that Python developers may face in their quest to write programs. Let's get cracking!

ERROR TYPES IN PYTHON

SYNTAX ERRORS

The first type of errors we are looking at are dubbed syntax errors. This errors exist to inform you that there is a rule you are violating and as a result the code will not execute at all. Consider the example below:



valid_voting_age=18
your_age=int(input('Enter your age: '))

if your_age >= valid_voting_age
  print('You can vote')

When that program is run, the code will not execute and an error will be thrown as shown below:

Syntax errors are actually useful since they highlight the exact spot where a violation has occurred and thus you can easily correct the mistake. In our case we forgot to add a colon in the condition if. That is:



valid_voting_age=18
your_age=int(input('Enter your age: '))

if your_age >= valid_voting_age:#new
  print('You can vote')

Let's move on to the second type of errors.

RUNTIME ERRORS

This type of error means that your syntax is correct but it will make the code fail when run. Generally speaking, the Python interpreter understands what you are trying to say but hits an obstacle when following your instructions. This is where no error was detected when the program was parsed and is only realized when a specific line is executed. This makes the program to exit unexpectedly or in other terms, crash.
Consider the following classical example:



num1=55
num2=0
print(num1/num2)

When we run that, we get:

We are trying to divide a number by zero and that crashes our program. Other examples of runtime errors include:
1.Performing an operation on incompatible types.
2.Using an identifier which has not been defined.
3.Accessing a list element, dictionary value or object attribute which does not exist.
4.Accessing a file which does not exist.
To catch runtime errors, you can add in checks to deal with bad inputs and edge cases. In the example above, we may:



num1=55
num2=0
try:
  print(num1/num2)
except ZeroDivisionError:
  print('Cannot divide a number by zero')

LOGICAL ERRORS

These types of errors are a real pain as they are hard to fix.Why? The program runs without crashing but the end result is not what we expect leaving us wondering where hell broke loose. We will not get an error message because no syntax or runtime errors were detected. More often than not, logical errors are as a result of the programmer's carelessness. Examples of things that can lead to logical errors include:
1.Indenting a block to the wrong level
2.Getting operator precedence wrong
3.Making a mistake in a boolean expressions
Among others. Consider the example below:



num1=20
num2=30
if num1>num2:
  print(f'{num1} is less than {num2}')

When we run that code, nothing will be returned to us that we can see. The console will be:

But we expect a print statement right? We will not see it because we used a greater than > operator instead of <.
So because we were not careful enough the algorithm becomes incorrect. Thus we should always exercise care when writing code and proof-read what we have written to ensure nothing has been entered carelessly.

FIGURING OUT WHAT WENT WRONG

OBSERVE THE STACK TRACE

1.Last calls are always on the top
2.Your code is at the bottom
3.Follow line numbers

FIND YOUR MISTAKE

1.Reread your code
2.Check the docs
3.Use sites like StackOverflow, quora, reddit
4.Take a break from the screen
5.Ask someone for help

That's all I have for today. If you enjoyed reading this article then show your love and leave your thoughts down below. Follow me for future updates here and on Twitter

Collect payments in your Django ecommerce portal using Flutterwave ~PART 2

Nick Langat — Tue, 27 Jul 2021 19:49:28 +0000

Hello everyone and welcome to part 2 of the series where we are building an electronics store and then collect payments from users who can choose how to pay. In case you missed part 1 then here it is.We ended it where we had the following page on (http://localhost:8000/)

Well, in this part we are going to create a detail page for an individual product and then add a form to collect payment details including the name, email and phone number of the user. Once we have that data, we shall connect with Flutterwave to process the payment. We will then grab the response from Flutterwave in our callback function and do stuff with it. Sounds fun? Let's get dirty!

PRODUCT DETAIL

We need to find a way of accessing a single product when its name is clicked. Open views.py and add the following code to it below what we already have:

def product_detail(request, pk):
    data = Product.objects.get(id=pk)
    ctx={
        'product':data
    }
    return render(request,
                  'product.html',
                  ctx)

So we are grabbing the current product's ID and the asking the database to give us only its details. We add the details to our context variable and render it in the HTML. Open urls.py and add a path like so:

path('product/<int:pk>/details', product_detail, name='details'),

Next up let's update the 'templates/products.html' like in the paste found here
Then open 'templates/product.html' and add to it the code found here
With all that in place access the homepage and click on any product and, hopefully, you should see its detailed page like the one below:

If you encounter an error please check the terminal console and fix before moving on.

PAYMENTS FORM

We need to capture the details of the user trying to buy a given product. In django the best way to do this is to present the customer with a form which they fill and then on submission, we grab the values the user entered. Create a new file inside 'electronics' called forms.py:

touch electronics/forms.py

Add the following code to it:

from django import forms

class PaymentForm(forms.Form):
    name = forms.CharField(label='Your name', max_length=100)
    email = forms.EmailField()
    phone=forms.CharField(max_length=15)
    amount = forms.FloatField()

Our form is ready, next let's update the product detail function to contain the form and the logic to get the form data once a user clicks submit button:


def product_detail(request, pk):
    data = Product.objects.get(id=pk)
    if request.method=='POST':
        form = PaymentForm(request.POST)
        if form.is_valid():
             name=  form.cleaned_data['name']
             email = form.cleaned_data['email']
             amount = form.cleaned_data['amount']
             phone = form.cleaned_data['phone']
             return redirect(str(process_payment(name,email,amount,phone)))
    else:
        form = PaymentForm()
    ctx={
        'product':data,
        'form':form
    }
    return render(request,
                  'product.html',
                  ctx)

We are adding our form to capture payment info.We are checking if the request verb is 'POST'.We then clean the form and get the values the user entered i.e name,email,phone. The amount will be hidden since we can access it from the product details.
Let's move on to create a method that will call Flutterwave's endpoint, inside the views.py add the code below to it.

def process_payment(name,email,amount,phone):
     auth_token= env('SECRET_KEY')
     hed = {'Authorization': 'Bearer ' + auth_token}
     data = {
                "tx_ref":''+str(math.floor(1000000 + random.random()*9000000)),
                "amount":amount,
                "currency":"KES",
                "redirect_url":"http://localhost:8000/callback",
                "payment_options":"card",
                "meta":{
                    "consumer_id":23,
                    "consumer_mac":"92a3-912ba-1192a"
                },
                "customer":{
                    "email":email,
                    "phonenumber":phone,
                    "name":name
                },
                "customizations":{
                    "title":"Supa Electronics Store",
                    "description":"Best store in town",
                    "logo":"https://getbootstrap.com/docs/4.0/assets/brand/bootstrap-solid.svg"
                }
                }
     url = ' https://api.flutterwave.com/v3/payments'
     response = requests.post(url, json=data, headers=hed)
     response=response.json()
     link=response['data']['link']
     return link

Notice that this method loads a secret key from a .env file. Thus create a file in 'electronics' called .env and add the code below:

SECRET_KEY='YOUR FLUTTERWAVE SECRET KEY'

OBTAINING FLUTTERWAVE SECRET KEY

Login to your Flutterwave account and head over to API settings. Generate new keys or copy what you already have if you had earlier generated. What we want in particular is the 'SECRET KEY'. Copy it and add it to the .env file you earlier created.
Next add the following code at the top of your views.py to initialize our environment variables:

import environ
# Initialise environment variables
env = environ.Env()
environ.Env.read_env()

REDIRECT URL

When we make a post request to Flutterwave with all the details collected,they will call your specified redirect_url and post the response to you. They will also append your transaction ID (transaction_id), transaction reference (tx_ref) and the transaction status (status) as query params to the redirect_url like: /tx_ref=ref&transaction_id=30490&status=successful. Once we have this response data we can verify transaction status and provide value to our customers like saving it in the database and providing feedback to users. In this case we are going to simply print the response on the console. Feel free to play around with the response.
Add the following function to views.py:

from django.views.decorators.http import require_http_methods
from django.http import HttpResponse


@require_http_methods(['GET', 'POST'])
def payment_response(request):
    status=request.GET.get('status', None)
    tx_ref=request.GET.get('tx_ref', None)
    print(status)
    print(tx_ref)
    return HttpResponse('Finished')

Then update urls.py like so:

from os import name
from django.contrib import admin
from django.urls import path
from django.conf import settings
from django.conf.urls.static import static
from electronics.views import list_products, payment_response, product_detail

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', list_products, name='list'),
    path('product/<int:pk>/details', product_detail, name='details'),
    path('callback', payment_response, name='payment_response')
 ]
if settings.DEBUG:
    urlpatterns += static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)

UPDATE PRODUCT DETAIL HTML

We have all the logic to handle payment collection. The next thing is to update 'templates/product.html' to reflect this change as well. Copy the code found on this paste and paste it on your file.
Spin the server and head over to the homepage. Select any one product and enter customer name, email and phone and click submit. You should see a payment modal similar to the one below:

You can also opt to pay using bank card:

DONE DEAL

Phew! If you followed up to this point then pat yourself! That was some load of work. Congratulations for completing the series. In the series we were able to create an electronics store, collect payment from the user who had a choice of picking mobile money or card and then retrieved the transaction status and reference number for value addition.
If you have any questions leave them down below and I'll do my best to answer those.
Find me on Twitter
and
My personal website.
Untill next time, happy hacking!

Collect payments in your Django ecommerce portal using Flutterwave ~PART 1

Nick Langat — Mon, 26 Jul 2021 10:12:14 +0000

It is great to see most businesses going digital as opposed to the traditional way of doing things(mostly manually). Assuming you are running an online electronics store, you may want your customers to be able to make payments on the spot and while at it, give them the flexibility of selecting whether to pay using mobile money or card.

My name is Nick and in this two-part tutorial, we are going to create a simple electronics store using Django and then collect payments from customers using Flutterwave.

PROJECT SETUP

Let's quickly create a Django project by navigating to the desktop directory and opening a terminal window then:

mkdir django_flutterwave && cd django_flutterwave

Next let's create a new virtual env and install dependencies we will need.

virtualenv env

source env/bin/activate

pip install django requests django-environ Pillow

So aside from django we need:
1.requests library-to make calls to the payments endpoint
2.django-environ- to securely store our environment variables
3.Pillow to help with image processing
Let's create the project:

django-admin startproject django_store .
python manage.py startapp electronics

Remember to add 'electronics' to the list of installed apps in the project's settings.py.

MODELS

Open electronics/models.py and add the following code to it:

from django.db import models

# Create your models here.
class Product(models.Model):
    name=models.CharField(max_length=250)
    image=models.ImageField(upload_to='product_images')
    price=models.FloatField()

    def __str__(self) -> str:
        return str(self.name)

#Register it in admin
from django.contrib import admin
admin.site.register(Product)

The next step is to run makemigrations and finally migrate commands to register our database table.
Spin up the server using runserver command.
Create a superuser using the createsuperuser command and login to (http://localhost:8000/admin/) and add a couple of electronic products.

SETTINGS CONFIGURATION

Notice that our Product class accepts images so let's update our settings.py to reflect this. At the bottom of the file add the following code:

MEDIA_ROOT = os.path.join(BASE_DIR, 'media')
MEDIA_URL = '/media/'

open the project's urls.py and add the following code:

from django.contrib import admin
from django.urls import path
from django.conf import settings
from django.conf.urls.static import static

urlpatterns = [
    path('admin/', admin.site.urls),
 ]
if settings.DEBUG:
    urlpatterns += static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)

To tell django where to find our HTML markup, add the following to the TEMPLATES SECTION inside the DIRS part:

os.path.join(BASE_DIR, 'templates')

With that in place let's move on.

VIEWS

All the business logic will sit here. We need to list the products from the database so let's create a function to handle that.
Add the following code to the views.py.

from django.shortcuts import render
from .models import Product
# Create your views here.

def list_products(request):
    products=Product.objects.all()
    ctx={
        'products':products
    }
    return render(request, 'products.html', ctx)

update the project's urls.py like so:

from os import name
from django.contrib import admin
from django.urls import path
from django.conf import settings
from django.conf.urls.static import static
from electronics.views import list_products

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', list_products, name='list'),
 ]
if settings.DEBUG:
    urlpatterns += static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)

TEMPLATES

Create a root level folder called 'templates' and inside it create 'products.html' file. Now the content to this file can be found on this paste
With that in place go ahead and restart the dev server and access (http://localhost:8000/) and you should surely see some UI like mine below:

THAT'S IT

Well I have to wrap up this part at this juncture. The goal here was to create the project, add products and display them on the homepage. I hope that is what you have on your end.
Thanks for taking time to read and follow along. I am working on part 2 so stay tuned!
Follow me here and on Twitter for updates.
Also if you have time visit my website here.
Cheers!