Admin.

py:

from django.contrib import admin

# Lee los metadatos de sus modelos para proporcionar una interfaz rápida

centrada en el modelo donde los usuarios de confianza pueden administrar el

contenido de su sitio. El uso recomendado por el administrador se limita a la

herramienta de gestión interna de una organización.

from .models import *

# importaremos de model hasta todo los métodos, variables del archivo de

estructua de datos model.py

# Register your models here.
admin.site.register(Customer)
admin.site.register(Product)
admin.site.register(Tag)
admin.site.register(Order)
# para
la gestión de un modelo de datos en la administración de
Django, con el código registraremos el modelo de dados a admin.py
url.py:
rom django.contrib import admin
from django.urls import path, include

from django.conf.urls.static import static
from django.conf import settings
urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include('accounts.urls')),
]

urlpatterns += static(settings.MEDIA_URL, document_root = settings.MEDIA_ROO
T)

# EN LA LISTA URLPATTERS INGRESAMOS LA FUNCION PATH donde esta la ruta de gestion de

datos que tiene django donde la ruta de línea admin.site.urls definiara que ruta le dica a django
que habilite la aplicación del sitio de administración

#y la otra función path agregaremos la dirección url desde el directorio de la aplicación del otro
url,py para si que el url,py principal de la url principal global no sea demasiado grande para leerlo.
url.py-accounts:
from django.urls import path
from . import views
#importamos views a directorio actual pore so ponemos el punto refiriendose
al directorio

urlpatterns = [
    
   
    #plantilla
    path('', views.home, name="home"),
    path('products/', views.products, name='products'),
    path('customer/<str:pk_test>/', views.customer, name="customer"),

    #crud
    path('create_order/<str:pk>/', views.createOrder, name="create_order"),
    path('update_order/<str:pk>/', views.updateOrder, name="update_order"),
    path('delete_order/<str:pk>/', views.deleteOrder, name="delete_order"),
    path('create_customer/', views.createCustomer, name="create_customer"),
    

    #login
    path('register/', views.registerPage, name="register"),
    path('login/', views.loginPage, name="login"),  
    path('logout/', views.logoutUser, name="logout"),

    #cliente
    path('account/', views.accountSettings, name="account"),
    path('user/', views.userPage, name="user-page"),

# luego en la lista o tuple urlpattera vamos a listar todos las url de

nuestra aplicacion importando desde views
# luego la variable name oara darle un nombre a una url dentro del arguemtno
de la ruta que significa que solo tenemso que el nombre de la url dentro del
atributo href en la plantilla
Setting.py
import os
# el import os, es la libreria que tiene por defecto Python la cual llama al
sistema operativo, que será herramienta para llamar la ruta actual donde se
ubica proyecto
from pathlib import Path

# Build paths inside the project like this: BASE_DIR / 'subdir'.
BASE_DIR = Path(__file__).resolve().parent.parent
# donde se ubica el proyecto

# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/3.2/howto/deployment/checklist/

# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = 'django-insecure-8otxbwgb2wmx$&t6!oc#*ggbdsj5caf%o
%9pouu66)4skx49-%'
# Se usa para produccion y es importante tenerla ya que django no funcionara
y no podra iniciar el proyecto

# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = True

ALLOWED_HOSTS = []
#

# Application definition

INSTALLED_APPS = [
    'django.contrib.admin', ->agregar y manejar o todas las interaction del
proyecto
    'django.contrib.auth', -> referencia parte de los usuario para gestionar
el usuario
    'django.contrib.contenttypes',
    'django.contrib.sessions', -> session que trabaja de django
    'django.contrib.messages',
    'django.contrib.staticfiles', -> a los archivos css, js para poder
renderizarlos
    'accounts.apps.AccountsConfig',-> cada vez que creacion nuestra
aplicacion lo añadimos a la lista de aplicaciones instaladas
    'django_filters',
    'crispy_forms',
]
# modulos que contiene el framework django

CRISPY_TEMPLATE_PACK = 'bootstrap4'

MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
]
# son la parte de la seguridad o gestion de seguridad por el framework

ROOT_URLCONF = 'crm1.urls'
#hace referencia al directorio url.py dentro de la carpeta principal, como
es un archivo principal por eso es que se enlaza

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [], -> en este campo se ingresara la ubicacion del template
        'APP_DIRS': True,
        'OPTIONS': {
            'context_processors': [
                'django.template.context_processors.debug',
                'django.template.context_processors.request',
                'django.contrib.auth.context_processors.auth',
                'django.contrib.messages.context_processors.messages',
            ],
        },
    },
]
# hace refernecia a los template donde va estar ubicadas los templates en el
proyecto, internamente django tiene un sistema de plantilla, que podemos
rendirizar el lado frontend
#tambiene tiene algunos procesadores de contextos

WSGI_APPLICATION = 'crm1.wsgi.application'

# Database
# https://docs.djangoproject.com/en/3.2/ref/settings/#databases

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': BASE_DIR / 'db.sqlite3',
    }
}

# Password validation
# https://docs.djangoproject.com/en/3.2/ref/settings/#auth-password-
validators

AUTH_PASSWORD_VALIDATORS = [
    {
        'NAME': 'django.contrib.auth.password_validation.UserAttributeSimila
rityValidator',
    },
    {
        'NAME': 'django.contrib.auth.password_validation.MinimumLengthValida
tor',
    },
    {
        'NAME': 'django.contrib.auth.password_validation.CommonPasswordValid
ator',
    },
    {
        'NAME': 'django.contrib.auth.password_validation.NumericPasswordVali
dator',
    },
]
# tenemos algunas validacion de contraseña para usuarios

# Internationalization
# https://docs.djangoproject.com/en/3.2/topics/i18n/

LANGUAGE_CODE = 'en-us'

TIME_ZONE = 'UTC'

USE_I18N = True

USE_L10N = True

USE_TZ = True

# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/3.2/howto/static-files/

STATIC_URL = '/static/'
MEDIA_URL = '/images/'

# la ruta donde va estar nuestros archivos static e images

STATICFILES_DIRS = [
    os.path.join(BASE_DIR, 'static')
]

MEDIA_ROOT = os.path.join(BASE_DIR, 'static/images')
# solo haremos la ruta del sistema operativo Os y usara una variable base
dir y te mostrara donde viene y tenemos que informar a que carpeta busca
cual es nombre del archivo
# Default primary key field type
# https://docs.djangoproject.com/en/3.2/ref/settings/#default-auto-field

DEFAULT_AUTO_FIELD = 'django.db.models.BigAutoField'
Signal.py:

from django.db.models.signals import post_save
from django.contrib.auth.models import User
from django.contrib.auth.models import Group

from .models import Customer

def customer_profile(sender, instance, created, **kwargs):
    if created:
        group = Group.objects.get(name='customer')
        instance.groups.add(group)
        Customer.objects.create(
            user=instance,
            name=instance.username,
            )
        print('Profile created!')

post_save.connect(customer_profile, sender=User)
# modulo se señales, que cada vez que una instancia de usuario finalice la ejecucion de si metodo
de guarder, se ejecutar la funcion, mejor dicho ayuda a la aplicación recibir notificación cuando
ocurren acciones en otra parte del marco
Decorator.py :
Sirvira para permisos y autentificacion basados en roles de usuario

from django.http import HttpResponse
from django.shortcuts import redirect

def unauthenticated_user(view_func): -> arguemtno que es una vista de django

    def wrapper_func(request, *args, **kwargs):->
#  args y ** kwargs se utilizan para pasar un número variable de argumentos a una
función. El asterisco simple se usa para argumentos sin palabras clave y el doble
para argumentos con palabras clave.
        if request.user.is_authenticated:
# aqui haremos una condicional que por el atributo is_authenticated hara para saber si el
usuario ha sido autenticado

            return redirect('home')
        else:
            return view_func(request, *args, **kwargs)
#si no es asi me return al registro o login de la pagina

    return wrapper_func

def allowed_users(allowed_roles=[]):
    def decorator(view_func):
        def wrapper_func(request, *args, **kwargs):
# crearesmo tres capas de funciones

            group = None
            if request.user.groups.exists():
                group = request.user.groups.all()[0].name

            if group in allowed_roles:
                return view_func(request, *args, **kwargs)
            else:
                return HttpResponse('You are not authorized to view this pag
e')
        return wrapper_func
    return decorator

def admin_only(view_func):
    def wrapper_function(request, *args, **kwargs):
        group = None
        if request.user.groups.exists():
            group = request.user.groups.all()[0].name

        if group == 'customer':
            return redirect('user-page')

        if group == 'admin':
            return view_func(request, *args, **kwargs)

    return wrapper_function
@unauthenticated_user
def registerPage(request):

    form = CreateUserForm()
    if request.method == 'POST':
        form = CreateUserForm(request.POST)
        if form.is_valid():
            user = form.save()
            username = form.cleaned_data.get('username')

            messages.success(request, 'Account was created for ' + username)

            return redirect('login')
        

    context = {'form':form}
    return render(request, 'accounts/register.html', context)

@unauthenticated_user
def loginPage(request):

    if request.method == 'POST':
        username = request.POST.get('username')
        password =request.POST.get('password')

        user = authenticate(request, username=username, password=password)
        if user is not None:
            login(request, user)
            return redirect('home')
        else:
            messages.info(request, 'Username OR password is incorrect')

    context = {}
    return render(request, 'accounts/login.html', context)

def logoutUser(request):
    logout(request)
    return redirect('login')

@login_required(login_url='login')
@admin_only
def home(request):
    orders = Order.objects.all()
    customers = Customer.objects.all()

    total_customers = customers.count()

    total_orders = orders.count()
    delivered = orders.filter(status='Delivered').count()
    pending = orders.filter(status='Pending').count()

    context = {'orders':orders, 'customers':customers,
    'total_orders':total_orders,'delivered':delivered,
    'pending':pending }

    return render(request, 'accounts/dashboard.html', context)

@login_required(login_url='login')
@allowed_users(allowed_roles=['customer'])
def userPage(request):
    orders = request.user.customer.order_set.all()

    total_orders = orders.count()
    delivered = orders.filter(status='Delivered').count()
    pending = orders.filter(status='Pending').count()

    print('ORDERS:', orders)
    context = {'orders':orders, 'total_orders':total_orders,
    'delivered':delivered,'pending':pending}
    return render(request, 'accounts/user.html', context)

@login_required(login_url='login')
@allowed_users(allowed_roles=['customer'])
def accountSettings(request):
    customer = request.user.customer
    form = CustomerForm(instance=customer)

    if request.method == 'POST':
        form = CustomerForm(request.POST, request.FILES,instance=customer)
        if form.is_valid():
            form.save()

    context = {'form':form}
    return render(request, 'accounts/account_settings.html', context)

@login_required(login_url='login')
@allowed_users(allowed_roles=['admin'])
def products(request):
    products = Product.objects.all()

    return render(request, 'accounts/products.html', {'products':products})

@login_required(login_url='login')
@allowed_users(allowed_roles=['admin'])
def customer(request, pk_test):
    customer = Customer.objects.get(id=pk_test)

    orders = customer.order_set.all()
    order_count = orders.count()

    myFilter = OrderFilter(request.GET, queryset=orders)
    orders = myFilter.qs 
    context = {'customer':customer, 'orders':orders, 'order_count':order_cou
nt,
    'myFilter':myFilter}
    return render(request, 'accounts/customer.html',context)

@login_required(login_url='login')
@allowed_users(allowed_roles=['admin'])
def createOrder(request, pk):
    OrderFormSet = inlineformset_factory(Customer, Order, fields=('product', 
'status') )
    customer = Customer.objects.get(id=pk)
    formset = OrderFormSet(queryset=Order.objects.none(),instance=customer)
    
    if request.method == 'POST':
        
        form = OrderForm(request.POST)
        formset = OrderFormSet(request.POST, instance=customer)
        if formset.is_valid():
            formset.save()
            return redirect('/')

    context = {'form':formset}
    return render(request, 'accounts/order_form.html', context)

@login_required(login_url='login')
@allowed_users(allowed_roles=['admin'])
def updateOrder(request, pk):
    order = Order.objects.get(id=pk)
    form = OrderForm(instance=order)
    print('ORDER:', order)
    if request.method == 'POST':

        form = OrderForm(request.POST, instance=order)
        if form.is_valid():
            form.save()
            return redirect('/')

    context = {'form':form}
    return render(request, 'accounts/update_form.html', context)
@login_required(login_url='login')
@allowed_users(allowed_roles=['admin'])
def deleteOrder(request, pk):
    order = Order.objects.get(id=pk)
    if request.method == "POST":
        order.delete()
        return redirect('/')

    context = {'item':order}
    return render(request, 'accounts/delete.html', context)

def createCustomer(request):

    context = {
        'form': CustomerForm()
    }
    if request.method =="POST":
        form = CustomerForm(data=request.POST, files=request.FILES)
        if form.is_valid():
            form.save()
            context["mensaje"]="GUARDADO EXITOSO"
        else:
            context['form'] = form

    return render(request, 'accounts/create_customer.html', context)

#
el request:

El parámetro de solicitud es un HttpRequestobjeto que contiene datos sobre la solicitud

# request.method es objetos de solicitud y respuesta para pasar el estado a través del
sistema . Cuando se solicita una página, Django crea un objeto HttpRequest que contiene
metadatos sobre la solicitud. Luego, Django carga la vista apropiada, pasando
HttpRequest como primer argumento a la función de vista.

#La función login_required de Django se utiliza para

proteger las vistas en sus aplicaciones web
obligando al cliente a autenticarse con un usuario
que haya iniciado sesión válido.