How to Generate a Random and Unique Order ID for a Purchase with Python in Django

In this article, we show how to generate a random and unique order ID for a purchase with Python in Django.

When a customer on a website purchases something, most ecommerce sites create a random an order ID. This order ID is usually unique, so that if a customer calls support for a partcular purchase, s/he can reference the order ID number, and the support staff can just look up the purchase through that number.

This is a smart practice.

The order ID should be unique, so that it only references a single order.

Of course, you can go off of the id attribute of the Order database table that you create for each order, but this isn't best practice. Because if you do it this way, a customer can know exactly how many orders there have been on your ecommerce. Imagine a customer getting an order ID of 4. S/he could then make another purchase and get an order ID of 5. At that point, s/he could just figure out that the orders on the site are sequential and would know they're just the 4th or 5th order on the site. At that point, they would know that the site barely has any customers, which you don't want.

Therefore, it's best to generate a random order ID.

We can write Python code within the Django framework to create this order ID.

models.py File

Inside of the models.py file, we have our Order model.

We also must insert the value of the order_id into the order_id field using a pre_save signal in Django.

from django.db import models from carts.models import Cart from .utils import unique_order_id_generator from django.db.models.signals import pre_save ORDER_STATUS_CHOICES= ( ('Not Yet Shipped', 'Not Yet Shipped'), ('Shipped', 'Shipped'), ('Cancelled', 'Cancelled'), ('Refunded', 'Refunded'), ) class Order(models.Model): order_id= models.CharField(max_length=120, blank= True) cart= models.ForeignKey(Cart) status= models.CharField(max_length=120, default='Not Yet Shipped', choices= ORDER_STATUS_CHOICES) shipping_total= models.DecimalField(default=5.99, max_digits=100, decimal_places=2) total= models.DecimalField(default=0.00, max_digits=100, decimal_places=2) def __str__(self): return self.order_id def pre_save_create_order_id(sender, instance, *args, **kwargs): if not instance.order_id: instance.order_id= unique_order_id_generator(instance) pre_save.connect(pre_save_create_order_id, sender=Order)

So the first thing is we have to import the Cart model we are created in the carts app. This carts model contains all the items that the user has purchased. We make this Cart model a ForeignKey to this Order model.

We then import a function, unique_order_id_generator, which we will create in the utils.py file within this orders app.

We then have to import pre_save from django.db.models.signals

We then create a tuple. This will contain the various order statuses, such as 'Not Yet Shipped', 'Shipped', 'Cancelled', 'Refunded'. We put this in the status form field of the Order model.

We next create a model called Order.

So we have a number of fields.

For the purpose of this article, the only field we are interested in is the order_id form field.

We create a function, pre_save_create_order_id, to presave the value of the field, order_id. If instance.order_id is None, we set order_id to, unique_order_id_generator(instance)

What this does is it executes the function in the utils.py file and returns a random and unique order_id, which then gets saved to the Order model through a pre_save signal.

So next we go to the random order ID generator function in the utils.py file.

Random, Unique Order ID Generator

So the next thing is we must now create the random order ID generator. We do this in the utils.py file of our app, though we can also put it in the app of the project directory.

Below is the code in the utils.py file.

import random import string def random_string_generator(size=10, chars=string.ascii_lowercase + string.digits): return ''.join(random.choice(chars) for _ in range(size)) def unique_order_id_generator(instance): order_new_id= random_string_generator() Klass= instance.__class__ qs_exists= Klass.objects.filter(order_id= order_new_id).exists() if qs_exists: return unique_order_id_generator(instance) return order_new_id

We create first a function, random_string_generator. This function will generator a random string of 10 characters.

We then create a function, unique_order_id_generator

This function creates a random string with the random_string_generator() function and places it within the order_new_id variable.

We then check to see if this order ID exists already within the database. If it exists, we start the function back from the start with the line, return unique_order_id_generator(instance). If it does not exists, we return the value, order_new_id

The value, order_new_id, is what gets inserted into the order_id form field of the Order database

Now each time an instance of the Order model is created, a random and unique order ID will be created.

And this is how to generate a random and unique order ID with Python in Django.

Related Resources

How to Randomly Select From or Shuffle a List in Python