O que vamos fazer nessa aula já vimos na aula14 em que criamos os métodos:
random_string_generator() e o unique_slug_generator() no src/products/utils.py.

Como o código desses métodos do src/products/utils.py é um código que pode ser usado por outros componentes do ecommerce, vamos tirar ele da pasta products e colocar na pasta src/e_commerce.

Iremos utilizar ele para gerar os IDs dos pedidos também.

Para facilitar, delete o src/products/utils.py.

Crie o src/e_commerce/utils.py que é exatamente a mesma coisa, só mudamos a pasta e criamos o método unique_order_id_generator().

Agora cole o conteúdo abaixo:

src/e_commerce/utils.py


import random
import string

from django.utils.text import slugify


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):
    """
    This is for a Django project with an order_id field
    """
    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

def unique_slug_generator(instance, new_slug=None):
    """
    This is for a Django project and it assumes your instance 
    has a model with a slug field and a title character (char) field.
    """
    if new_slug is not None:
        slug = new_slug
    else:
        slug = slugify(instance.title)

    Klass = instance.__class__
    qs_exists = Klass.objects.filter(slug = slug).exists()
    if qs_exists:
        new_slug = "{slug}-{randstr}".format(
                    slug = slug,
                    randstr = random_string_generator(size = 4)
                )
        return unique_slug_generator(instance, new_slug = new_slug)
    return slug

Por causa da mudança de pasta, temos que atualizar o import do utils.py em alguns arquivos.

No models do products.

src/products/models.py


from django.db.models import Q
from django.db import models
from e_commerce.utils import unique_slug_generator
from django.db.models.signals import pre_save
from django.urls import reverse

#Custom queryset
class ProductQuerySet(models.query.QuerySet):
    
    def active(self):
        return self.filter(active = True)

    def featured(self):
        return self.filter(featured = True, active = True)

    def search(self, query):
        lookups = (Q(title__contains = query) | 
                        Q(description__contains = query) | 
                        Q(price__contains = query))
        return self.filter(lookups).distinct()

class ProductManager(models.Manager):
    
    def get_queryset(self):
        return ProductQuerySet(self.model, using = self._db)
    
    def all(self):
        return self.get_queryset().active()

    def featured(self):
        #self.get_queryset().filter(featured = True)
        return self.get_queryset().featured()

    def get_by_id(self, id):
        qs = self.get_queryset().filter(id = id)
        if qs.count() == 1:
            return qs.first()
        return None

    def search(self, query):
        return self.get_queryset().active().search(query)

# Create your models here.
class Product(models.Model): #product_category
    title       = models.CharField(max_length=120)
    slug        = models.SlugField(blank = True, unique = True)
    description = models.TextField()
    price       = models.DecimalField(decimal_places=2, max_digits=20, default=100.00)
    image       = models.FileField(upload_to = 'products/', null = True, blank = True)
    featured    = models.BooleanField(default = False)
    active      = models.BooleanField(default = True)
    timestamp   = models.DateTimeField(auto_now_add = True)


    objects = ProductManager()

    def get_absolute_url(self):
        #return "/products/{slug}/".format(slug = self.slug)
        return reverse("products:detail", kwargs={"slug": self.slug})
    
    #python 3
    def __str__(self):
        return self.title
        
    #python 2
    def __unicode__(self):
        return self.title

def product_pre_save_receiver(sender, instance, *args, **kwargs):
    if not instance.slug:
        instance.slug = unique_slug_generator(instance)

pre_save.connect(product_pre_save_receiver, sender = Product)

Agora o e_commerce/tags/models.py

e_commerce/tags/models.py


from django.db import models
from e_commerce.utils import unique_slug_generator
from products.models import Product
from django.db.models.signals import pre_save

class Tag(models.Model):
    title = models.CharField(max_length = 120)
    slug = models.SlugField()
    timestamp = models.DateTimeField(auto_now_add = True)
    active = models.BooleanField(default = True)
    products = models.ManyToManyField(Product, blank = True)

    def __str__(self):
        return self.title

def tag_pre_save_receiver(sender, instance, *args, **kwargs):
    if not instance.slug:
        instance.slug = unique_slug_generator(instance)

pre_save.connect(tag_pre_save_receiver, sender = Tag)

E no e_commerce/orders/models.py o import do unique_order_id_generator() e do pre_save().

E o vamos criar o pre_save_create_order_id() que por enquanto vai chamar a unique_order_id_generator() para atribuir a um pedido (Order) um id aleatório e salva no banco.

e_commerce/orders/models.py


from django.db import models
from e_commerce.utils import unique_order_id_generator
from django.db.models.signals import pre_save
from carts.models import Cart

ORDER_STATUS_CHOICES = (
    ('created', 'Criado'),
    ('paid', 'Pago'),
    ('shipped', 'Enviado'),
    ('refunded', 'Devolvido'),
)

class Order(models.Model):
    order_id = models.CharField(max_length = 120, blank = True)
    # billing_profile = ?
    # shipping_address = ?
    # billing_address
    cart = models.ForeignKey(Cart, on_delete=models.CASCADE, null = True)
    status = models.CharField(max_length = 120, default = 'created', choices = ORDER_STATUS_CHOICES )
    shipping_total = models.DecimalField(default = 5.99, max_digits = 100, decimal_places = 2)
    # Order 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)

Agora acesse http://127.0.0.1:8000/admin

Clique em Orders no painel admin e ligue um Order a um carrinho e salve, veja que foi criado automaticamente um ID aleatório para o Pedido.