Sitio web de comercio electrónico usando Django

Este proyecto trata sobre el desarrollo de un sitio web virtual ‘Sitio web de comercio electrónico’ . Proporciona al usuario una lista de los distintos productos disponibles para su compra en la tienda. Para la comodidad de las compras en línea, se proporciona un carrito de compras al usuario. Después de la selección de la mercancía, se envía para el proceso de confirmación del pedido. El sistema se implementa utilizando el framework web Django de Python. Para desarrollar un sitio web de comercio electrónico, es necesario estudiar y comprender muchas tecnologías.

Alcance : El alcance del proyecto se limitará a algunas funciones del sitio web de comercio electrónico. Mostrará productos, los clientes pueden seleccionar catálogos y seleccionar productos, y pueden eliminar productos de su carrito especificando la cantidad de cada artículo. Los artículos seleccionados se recogerán en un carrito. Al finalizar la compra, el artículo de la tarjeta se presentará como un pedido. Los clientes pueden pagar los artículos del carrito para completar un pedido. Este proyecto tiene un gran alcance de futuro. El proyecto también brinda seguridad con el uso de ID de inicio de sesión y contraseñas, para que ningún usuario no autorizado pueda acceder a su cuenta. La única persona autorizada que tenga la autoridad de acceso adecuada puede acceder al software.

Tecnologías utilizadas en el proyecto: 

Django framework y base de datos SQLite que viene por defecto con Django.

Habilidad requerida para construir el proyecto: 

Conocimiento de Python y conceptos básicos de Django Framework.

ER y diagramas de casos de uso

Interfaz de cliente:

1. El cliente compra un producto
2. Cantidad de cambios del cliente
3. El cliente añade un artículo al carrito.
4. Carrito de vistas del cliente
5. El cliente se retira
6. Cliente envía pedido

Diagrama ER para el cliente

Diagrama de caso de uso para el cliente

Interfaz de administración :

1. El administrador inicia sesión
2. El administrador inserta un elemento
3. El administrador elimina el elemento
4. El administrador modifica el elemento

Diagrama ER para Admin

Diagrama de casos de uso para administrador

Implementación paso a paso: 

• Crear proyecto normal: abra el IDE y cree un proyecto normal seleccionando Archivo -> Nuevo proyecto.
• Instalar Django: A continuación, instalaremos el módulo Django desde la terminal. Usaremos el terminal integrado PyCharm para hacer esta tarea. También se puede usar cmd en Windows para instalar el módulo ejecutando el comando python -m pip install django
• Comprobar la versión de Django instalada: para comprobar la versión de Django instalada, puede ejecutar el comando python -m django -version como se muestra a continuación.
• Crear proyecto Django: cuando ejecutamos el comando django-admin startproject , creará un proyecto Django dentro del proyecto normal que ya hemos creado aquí. django-admin startproject Nombre del proyecto.
• Compruebe la versión de Python3: python3 –version
• Ejecute el servidor web Django predeterminado: – Django proporciona internamente un servidor web predeterminado donde podemos iniciar nuestras aplicaciones. python manage.py comando runserver en la terminal . De forma predeterminada, el servidor se ejecuta en el puerto 8000. Acceda al servidor web en la URL resaltada.

Abra la carpeta del proyecto con un editor de texto. La estructura del directorio debería verse así:

Estructura del proyecto

Ahora agregue la aplicación de la tienda en el sitio web de comercio electrónico en settings.py .

urls.py

Este archivo contiene todos los patrones de URL utilizados por el sitio web

from django.contrib import admin
from django.urls import path, include
from django.conf.urls.static import static
from . import settings
  
urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include('store.urls'))
] + static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)

Modelos

La siguiente captura de pantalla muestra los modelos requeridos que necesitaremos crear. Estos modelos son tablas que se almacenarán en la base de datos SQLite.

Veamos cada modelo y los campos requeridos por cada modelo.

categoría.py

from django.db import models
  
  
class Category(models.Model):
    name = models.CharField(max_length=50)
  
    @staticmethod
    def get_all_categories():
        return Category.objects.all()
  
    def __str__(self):
        return self.name

cliente.py

from django.db import models
  
  
class Customer(models.Model):
    first_name = models.CharField(max_length=50)
    last_name = models.CharField(max_length=50)
    phone = models.CharField(max_length=10)
    email = models.EmailField()
    password = models.CharField(max_length=100)
  
    # to save the data
    def register(self):
        self.save()
  
    @staticmethod
    def get_customer_by_email(email):
        try:
            return Customer.objects.get(email=email)
        except:
            return False
  
    def isExists(self):
        if Customer.objects.filter(email=self.email):
            return True
  
        return False

productos.py

from django.db import models
from .category import Category
  
  
class Products(models.Model):
    name = models.CharField(max_length=60)
    price = models.IntegerField(default=0)
    category = models.ForeignKey(Category, on_delete=models.CASCADE, default=1)
    description = models.CharField(
        max_length=250, default='', blank=True, null=True)
    image = models.ImageField(upload_to='uploads/products/')
  
    @staticmethod
    def get_products_by_id(ids):
        return Products.objects.filter(id__in=ids)
  
    @staticmethod
    def get_all_products():
        return Products.objects.all()
  
    @staticmethod
    def get_all_products_by_categoryid(category_id):
        if category_id:
            return Products.objects.filter(category=category_id)
        else:
            return Products.get_all_products()

Pedidos.py

from django.db import models
from .product import Products
from .customer import Customer
import datetime
  
  
class Order(models.Model):
    product = models.ForeignKey(Products,
                                on_delete=models.CASCADE)
    customer = models.ForeignKey(Customer,
                                 on_delete=models.CASCADE)
    quantity = models.IntegerField(default=1)
    price = models.IntegerField()
    address = models.CharField(max_length=50, default='', blank=True)
    phone = models.CharField(max_length=50, default='', blank=True)
    date = models.DateField(default=datetime.datetime.today)
    status = models.BooleanField(default=False)
  
    def placeOrder(self):
        self.save()
  
    @staticmethod
    def get_orders_by_customer(customer_id):
        return Order.objects.filter(customer=customer_id).order_by('-date')

Vistas : 

En las vistas, creamos una vista llamada home.py, login.py, signup.py, cart.py, checkout.py, orders.py  que toma una solicitud y presenta un HTML como respuesta. Cree un home.html, login.html, signup.html, cart.html, checkout.html, orders.html en las plantillas. Y asigne las vistas a la carpeta store\urls.py. 

from django.contrib import admin
from django.urls import path
from .views.home import Index, store
from .views.signup import Signup
from .views.login import Login, logout
from .views.cart import Cart
from .views.checkout import CheckOut
from .views.orders import OrderView
from .middlewares.auth import auth_middleware
  
  
urlpatterns = [
    path('', Index.as_view(), name='homepage'),
    path('store', store, name='store'),
  
    path('signup', Signup.as_view(), name='signup'),
    path('login', Login.as_view(), name='login'),
    path('logout', logout, name='logout'),
    path('cart', auth_middleware(Cart.as_view()), name='cart'),
    path('check-out', CheckOut.as_view(), name='checkout'),
    path('orders', auth_middleware(OrderView.as_view()), name='orders'),
  
]

Los siguientes archivos muestran las vistas para cada funcionalidad del sitio. 

casa.py

from django.shortcuts import render, redirect, HttpResponseRedirect
from store.models.product import Products
from store.models.category import Category
from django.views import View
  
  
# Create your views here.
class Index(View):
  
    def post(self, request):
        product = request.POST.get('product')
        remove = request.POST.get('remove')
        cart = request.session.get('cart')
        if cart:
            quantity = cart.get(product)
            if quantity:
                if remove:
                    if quantity <= 1:
                        cart.pop(product)
                    else:
                        cart[product] = quantity-1
                else:
                    cart[product] = quantity+1
  
            else:
                cart[product] = 1
        else:
            cart = {}
            cart[product] = 1
  
        request.session['cart'] = cart
        print('cart', request.session['cart'])
        return redirect('homepage')
  
    def get(self, request):
        # print()
        return HttpResponseRedirect(f'/store{request.get_full_path()[1:]}')
  
  
def store(request):
    cart = request.session.get('cart')
    if not cart:
        request.session['cart'] = {}
    products = None
    categories = Category.get_all_categories()
    categoryID = request.GET.get('category')
    if categoryID:
        products = Products.get_all_products_by_categoryid(categoryID)
    else:
        products = Products.get_all_products()
  
    data = {}
    data['products'] = products
    data['categories'] = categories
  
    print('you are : ', request.session.get('email'))
    return render(request, 'index.html', data)

iniciar sesión.py

from django.shortcuts import render, redirect, HttpResponseRedirect
from django.contrib.auth.hashers import check_password
from store.models.customer import Customer
from django.views import View
  
  
class Login(View):
    return_url = None
  
    def get(self, request):
        Login.return_url = request.GET.get('return_url')
        return render(request, 'login.html')
  
    def post(self, request):
        email = request.POST.get('email')
        password = request.POST.get('password')
        customer = Customer.get_customer_by_email(email)
        error_message = None
        if customer:
            flag = check_password(password, customer.password)
            if flag:
                request.session['customer'] = customer.id
  
                if Login.return_url:
                    return HttpResponseRedirect(Login.return_url)
                else:
                    Login.return_url = None
                    return redirect('homepage')
            else:
                error_message = 'Invalid !!'
        else:
            error_message = 'Invalid !!'
  
        print(email, password)
        return render(request, 'login.html', {'error': error_message})
  
  
def logout(request):
    request.session.clear()
    return redirect('login')

registro.py

from django.shortcuts import render, redirect
from django.contrib.auth.hashers import make_password
from store.models.customer import Customer
from django.views import View
  
  
class Signup (View):
    def get(self, request):
        return render(request, 'signup.html')
  
    def post(self, request):
        postData = request.POST
        first_name = postData.get('firstname')
        last_name = postData.get('lastname')
        phone = postData.get('phone')
        email = postData.get('email')
        password = postData.get('password')
        # validation
        value = {
            'first_name': first_name,
            'last_name': last_name,
            'phone': phone,
            'email': email
        }
        error_message = None
  
        customer = Customer(first_name=first_name,
                            last_name=last_name,
                            phone=phone,
                            email=email,
                            password=password)
        error_message = self.validateCustomer(customer)
  
        if not error_message:
            print(first_name, last_name, phone, email, password)
            customer.password = make_password(customer.password)
            customer.register()
            return redirect('homepage')
        else:
            data = {
                'error': error_message,
                'values': value
            }
            return render(request, 'signup.html', data)
  
    def validateCustomer(self, customer):
        error_message = None
        if (not customer.first_name):
            error_message = "Please Enter your First Name !!"
        elif len(customer.first_name) < 3:
            error_message = 'First Name must be 3 char long or more'
        elif not customer.last_name:
            error_message = 'Please Enter your Last Name'
        elif len(customer.last_name) < 3:
            error_message = 'Last Name must be 3 char long or more'
        elif not customer.phone:
            error_message = 'Enter your Phone Number'
        elif len(customer.phone) < 10:
            error_message = 'Phone Number must be 10 char Long'
        elif len(customer.password) < 5:
            error_message = 'Password must be 5 char long'
        elif len(customer.email) < 5:
            error_message = 'Email must be 5 char long'
        elif customer.isExists():
            error_message = 'Email Address Already Registered..'
        # saving
  
        return error_message

carrito.py

from django.db import models
from .product import Products
from .customer import Customer
import datetime
  
  
class Order(models.Model):
    product = models.ForeignKey(Products,
                                on_delete=models.CASCADE)
    customer = models.ForeignKey(Customer,
                                 on_delete=models.CASCADE)
    quantity = models.IntegerField(default=1)
    price = models.IntegerField()
    address = models.CharField(max_length=50, default='', blank=True)
    phone = models.CharField(max_length=50, default='', blank=True)
    date = models.DateField(default=datetime.datetime.today)
    status = models.BooleanField(default=False)
  
    def placeOrder(self):
        self.save()
  
    @staticmethod
    def get_orders_by_customer(customer_id):
        return Order.objects.filter(customer=customer_id).order_by('-date')

pago.py

from django.shortcuts import render, redirect
  
from django.contrib.auth.hashers import check_password
from store.models.customer import Customer
from django.views import View
  
from store.models.product import Products
from store.models.orders import Order
  
  
class CheckOut(View):
    def post(self, request):
        address = request.POST.get('address')
        phone = request.POST.get('phone')
        customer = request.session.get('customer')
        cart = request.session.get('cart')
        products = Products.get_products_by_id(list(cart.keys()))
        print(address, phone, customer, cart, products)
  
        for product in products:
            print(cart.get(str(product.id)))
            order = Order(customer=Customer(id=customer),
                          product=product,
                          price=product.price,
                          address=address,
                          phone=phone,
                          quantity=cart.get(str(product.id)))
            order.save()
        request.session['cart'] = {}
  
        return redirect('cart')

pedidos.py

from django.shortcuts import render, redirect
from django.contrib.auth.hashers import check_password
from store.models.customer import Customer
from django.views import View
from store.models.product import Products
from store.models.orders import Order
from store.middlewares.auth import auth_middleware
  
  
class OrderView(View):
  
    def get(self, request):
        customer = request.session.get('customer')
        orders = Order.get_orders_by_customer(customer)
        print(orders)
        return render(request, 'orders.html', {'orders': orders})

Producción 

El proyecto ya incluye muchas características. Los principales beneficiados son tanto los clientes como los administradores que tardan más en comportarse en línea. Además, se pueden identificar e incorporar características adicionales en el futuro. Tomará más tiempo y esfuerzo comprender la necesidad y ajustarla a un sistema computarizado para acomodar funciones adicionales.

GitHub Enlace al proyecto