DJANGO

Clase 32 y 33
Django: Introducción
Les damos la bienvenida
Vamos a comenzar a grabar la clase
¿Qué es un Modelo?
Un modelo es la fuente única y definitiva de información sobre los
datos en Django. Contiene los campos y comportamientos esenciales
de los datos que se están almacenando. Generalmente, cada modelo se
asigna a una tabla de base de datos.
Recordemos
Creación de un Modelo
En el archivo models.py se van a definir cada modelo que contendrá
los campos y métodos que pueden ser utilizados para interactuar
con la base de datos.

Un modelo en Django se define mediante una clase Python que

hereda de la clase django.db.models.Model. Cada atributo de la
clase representa un campo en la base de datos, y Django
proporciona una variedad de tipos de campo y propiedades (como
CharField, IntegerField, etc.) que puedes usar para definir el tipo de
datos que cada campo debe contener.

ref: Modelos en Django

ref: Campos en Django
Creación de un Modelo
models.py

class Movie(models.Model):
title = models.CharField(max_length=100,verbose_name='Titulo')
director = models.CharField(max_length=100,verbose_name='Nombre')
release_date = models.DateField(verbose_name='Fecha de inicio',null=True,default=None)
banner = models.ImageField(upload_to='imagenes/',null=True,verbose_name='Portada')

def __str__(self):
return self.title
 Posibilidad de subir archivos al servidor
En el caso como el del modelo Movie, donde tendremos un campo que pueda guardar la ruta donde se almacenará un
archivo en el servidor, necesitamos instalar la librería Pillow y modificar la configuración del archivo settings.py y urls.py
del proyecto. Tener en cuenta que este paso es necesario si se manipulan modelos en los cuales queremos registrar
rutas de archivos que serán subidos al servidor, de caso contrario no son necesarios.
Desde la consola, ejecutamos el siguiente comando
pip install Pillow

settings.py urls.py (del proyecto)

Al final del archivo agregamos las siguientes líneas. Agregamos las importaciones antes de la lista urlpatterns y
sumamos a la lista la referencia del directorio de donde tiene que
buscar los archivos que se subirán al servidor

#donde vamos a ir guardar los archivos medias debug from django.conf.urls.static import static
MEDIA_URL = "/media/" from django.conf import settings
#media para produccion
MEDIA_ROOT = os.path.join(BASE_DIR,'media') urlpatterns = [
path('admin/', admin.site.urls),
path('api/',include('app.urls')),
]+ static(settings.MEDIA_URL,document_root=settings.MEDIA_ROOT)
Migración
En Django, una migración es un conjunto de instrucciones que le
python manage.py makemigrations dice a la base de datos cómo cambiar su estructura para reflejar las
Migrations for ‘app': actualizaciones hechas en los modelos de tu aplicación. Las
cac\migrations\0001_initial.py migraciones son una parte clave del proceso de desarrollo en
- Create model Movie Django, ya que facilitan la gestión de cambios en la estructura de la
base de datos de manera controlada y ordenada.

python manage.py migrate

Una vez que has creado la migración, necesitas aplicarla a la base
Operations to perform: de datos para que los cambios realmente se lleven a cabo. Puedes
Apply all migrations: cac hacer esto ejecutando el comando migrate de Django. Este
Running migrations: comando toma todas las migraciones pendientes y las aplica
Applying cac.0001_initial... OK secuencialmente, actualizando así la base de datos.
¿Qué es un API?
API es una abreviatura de Application Programing Interfaces, que en
español significa interfaz de Programación de Aplicaciones.

Es un conjunto de definiciones y protocolos que que permite que dos

programas se comuniquen entre sí. Es una forma de definir cómo se
deben solicitar y enviar datos entre diferentes componentes de
software. Puedes pensar en una API como un intermediario que
permite que una aplicación hable con otra, solicitando ciertos servicios
o datos y recibiendo respuestas en un formato específico.

ref: API - API REST

API REST
REST significa transferencia de estado representacional. Una API REST es un tipo específico de API que sigue ciertas
convenciones y principios arquitectónicos. Está diseñada para funcionar de manera eficiente en la web y utiliza los métodos
estándar de HTTP (como GET, POST, PUT y DELETE) para realizar operaciones en los datos.

En términos aún más simples, puedes pensar en una API REST como una interfaz que te permite interactuar con los datos
de una aplicación a través de la web utilizando solicitudes HTTP. Cada recurso (como un usuario o un artículo) tiene una
URL única, y puedes realizar acciones sobre esos recursos utilizando los métodos de HTTP. Por ejemplo, puedes usar GET
para obtener información, POST para agregar nueva información, PUT para actualizar información existente y DELETE para
eliminarla.
Instalación
En ambiente virtual de django (recomendado en requierements.txt)
pip install djangorestframework

settings.py
INSTALLED_APPS = [
...
'rest_framework’,
]

urls.py (del proyecto)

urlpatterns = [
... Incluye las url django authentication para el framework rest.
path('api-auth/', include('rest_framework.urls’)) Por defecto configurado en BasicAuthentication y
] SessionAuthentication

ref: Django Rest Framework

Serialización
El proceso de serialización en Django REST Framework implica definir un serializador, usarlo para convertir datos complejos
en un formato serializable, validar y deserializar esos datos, y luego enviar la representación resultante, generalmente en
formato JSON, como respuesta a través de tu API. Este proceso facilita la comunicación entre el servidor y el cliente al
convertir objetos complejos en un formato que pueda ser fácilmente interpretado por ambas partes.

ref: Django Rest Framework - Serializacion

Creación de un Serialización
serializers.py

from rest_framework import serializers

from app.models import Movie

class MovieSerializer(serializers.ModelSerializer):
reviews = serializers.StringRelatedField(many=True)

class Meta:
model = Movie
fields = ['id','title','director','release_date','banner']
Creación de métodos en la vista
En el archivo views.py de la aplicación vamos a crear las funciones necesarias para que se pueden atender las
peticiones de CREAR, MODIFICAR, ELIMINAR y CONSULTAR registros del modelo Movie. Se debe tener en cuenta
para completar el proceso, una vez definidos las funciones deberemos agregar en el archivo urls.py de la aplicación la
referencia que permita asociar una ruta con el método correspondiente.

En la referencia del framework, se puede observar que los métodos para atender las peticiones pueden agruparse, pero
en este ejemplo que veremos a continuación separaremos los métodos en cinco funciones distintas donde cada una
atenderá una petición particular con un método de petición distinto (GET, POST, PUT, DELETE).

ref: Django Rest Framework - Requests y Responses

También se pueden implementar por medio del concepto de Vistas Basadas en Clases que provee el framework de Django.
No se verá este tema en clases.

ref: Django Rest Framework - Vista Basada en Clases

Listar Películas
views.py
@api_view(['GET'])
def get_movies(request):
"""
Listar todos las peliculas
"""
#se buscan todos los registros guardados en la base
movies = Movie.objects.filter()
#cuando estás serializando múltiples instancias de un modelo
serializer = serializers.MovieSerializer(movies, many=True)
#Response es una clase que me permite devolver una respuesta
#que cumple con los estandares de API-REST
return Response(serializer.data)

urlpatterns = [
urls.py path('', views.index,name='inicio_app'),
path('movies/', views.get_movies),
]
Crear Películas
views.py
@api_view(['POST'])
def create_movie(request):
#Se seriala los datos recibidos desde el formulario
serializer = serializers.MovieSerializer(data=request.data)
#Se ejecutan las validaciones
if serializer.is_valid():
#Se registra en base de datos
serializer.save()
#Se genera la respuesta que deseamos devolver
response = {'status':'Ok',
'message':'Pelicula creada exitosamente',
'data':serializer.data}
return Response(data= response, status=status.HTTP_201_CREATED)
response = {'status':'Error',
'message':'No se pudo crear la pelicula',
'errors':serializer.errors}
return Response(data=response, status=status.HTTP_400_BAD_REQUEST)

urlpatterns = [
. . .
urls.py path('create_movie/', views.create_movie),
. . .
]
Detalle de una Película
views.py
@api_view(['GET'])
def detail_movie(request, id):
"""
Muestra una pelicula.
"""
try:
#Se busca la pelicula en base por el id
movie = Movie.objects.get(pk=id)
except Movie.DoesNotExist:
return Response(status=status.HTTP_404_NOT_FOUND,data='Recurso no encontrado')

serializer = serializers.MovieSerializer(movie)
return Response(serializer.data)

urlpatterns = [
. . .
urls.py path('movies/<int:id>/', views.detail_movie),
. . .
]
Eliminar una Película
views.py
@api_view(['DELETE'])
def delete_movie(request, id):
"""
Eliminar una pelicula.
"""
try:
movie = Movie.objects.get(pk=id)
except Movie.DoesNotExist:
return Response(status=status.HTTP_404_NOT_FOUND,data='Recurso no encontrado')
#Se elimina la pelicula en base de datos
movie.delete()
return Response({'message':'Se elimino la movie'},status=status.HTTP_200_OK)

urlpatterns = [
. . .
urls.py path('delete_movie/<int:id>/', views.delete_movie),
. . .
]
 Actualizar una Película
views.py urls.py
@api_view(['PUT']) urlpatterns = [
def update_movie(request, id): . . .
""" path('update_movie/<int:id>/',
Actualiza una pelicula. views.update_movie),
""" . . .
try: ]
movie = Movie.objects.get(pk=id)
except Movie.DoesNotExist:
return Response(status=status.HTTP_404_NOT_FOUND,data='Recurso no encontrado')

serializer = serializers.MovieSerializer(movie, data=request.data)

if serializer.is_valid():
serializer.save()
response = {'status':'Ok',
'message':'Pelicula modificada exitosamente',
'data':serializer.data}
return Response(data=response)
response = {'status':'Error',
'message':'No se pudo modificar la pelicula',
'errors':serializer.errors}
return Response(data=response, status=status.HTTP_400_BAD_REQUEST)
No te olvides de completar la
asistencia y consultar dudas
Recordá:
● Revisar la Cartelera de Novedades.
● Hacer tus consultas en el Foro.

TODO EN EL AULA VIRTUAL