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.
