Fundamentos de Django

1

¿Qué es Django?

2

¿Cómo instalar Django?

3

Entendiendo la arquitectura de Django

4

Qué es el patrón MVT (Model, View y Template)

La M en el Patrón: Modelo

5

Introducción a Modelos y Bases de Datos

Manejo Avanzado de Modelos y Bases de Datos

6

Gestión de Modelos y Bases de Datos en Django con SQLite

7

Inserción de Datos con Django

8

Actualización y Eliminación de Datos en Django

Relaciones y Asociaciones entre Modelos

9

Creación y Gestión de Relaciones entre Modelos en Django

10

Relaciones Muchos a Muchos (N:N) en Django

11

Relaciones Uno a Uno (1:1) en Django

12

Queries y Filtros en Django: Optimización y Estrategias Avanzadas

Configuración de URLs y Vistas Avanzadas

13

Gestión de URLs en Django: Configuración, Rutas y Mejores Prácticas

14

Vistas Basadas en Clases en Django

La T en el Patrón: Plantillas o Templates

15

Personalización de Interfaz con Plantillas en Django

Desarrollo de Aplicaciones en Django

16

Configuración del Proyectos en Django

17

Creación del Modelo para la Aplicación 'Products' en Django

18

Cómo Crear Migraciones de Datos en Django

19

Creación de la Aplicación 'Products' con Formularios en Django

20

Integracion de TailwindCSS en Django

21

Django Admin

22

Manejo de Sesiones en Django

23

Manejo de Órdenes en CoffeShop

24

Manejo de Pedidos en CoffeShop

25

Mixings en vistas basadas en clases

26

Agregar productos a la orden

Django Rest Framework

27

Django REST Framework

Despliegue de aplicaciones Django

28

Configurar PostgreSQL en AWS con Django

29

Variables de entorno en Django

30

¿Cómo usar Unit Testing en Django?

31

Debugging en Django

32

Desplegar aplicaciones de Django en AWS

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

No se trata de lo que quieres comprar, sino de quién quieres ser. Aprovecha el precio especial.

Antes: $249

Currency
$209

Paga en 4 cuotas sin intereses

Paga en 4 cuotas sin intereses
Suscríbete

Termina en:

14 Días
16 Hrs
24 Min
52 Seg
Curso de Django

Curso de Django

Luis Martínez

Luis Martínez

Creación de la Aplicación 'Products' con Formularios en Django

19/32
Recursos

La funcionalidad de formularios en Django permite a los desarrolladores crear, validar y gestionar formularios de manera eficiente y organizada. A continuación, exploraremos cómo crear formularios en Django paso a paso.

¿Cómo se crean formularios en Django?

Para crear un nuevo formulario en Django, primero se debe crear una clase que herede de forms.Form. Esta clase contendrá todos los campos que queremos incluir en el formulario.

  1. Crear el archivo forms.py:
    from django import forms
    
    class ProductForm(forms.Form):
        name = forms.CharField(max_length=200, label='Nombre')
        description = forms.CharField(max_length=300, label='Descripción')
        price = forms.DecimalField(max_digits=10, decimal_places=2, label='Precio')
        available = forms.BooleanField(initial=True, label='Disponible', required=False)
        photo = forms.ImageField(label='Foto', required=False)
    

¿Cómo se manejan los datos del formulario en Django?

Una vez que el formulario está creado, necesitamos definir cómo manejar los datos cuando el usuario envía el formulario. Esto incluye validar los datos y guardarlos en la base de datos.

  1. Método save para guardar datos:
    def save(self):
        from .models import Product
        data = self.cleaned_data
        Product.objects.create(
            name=data['name'],
            description=data['description'],
            price=data['price'],
            available=data['available'],
            photo=data['photo']
        )
    

¿Cómo se crea la vista para el formulario?

La vista conecta el formulario con el template y maneja el request del usuario. Usaremos una vista genérica de Django para simplificar este proceso.

  1. Crear la vista:
    from django.views.generic.edit import FormView
    from django.urls import reverse_lazy
    from .forms import ProductForm
    
    class ProductFormView(FormView):
        template_name = 'products/add_product.html'
        form_class = ProductForm
        success_url = reverse_lazy('product_list')
    
        def form_valid(self, form):
            form.save()
            return super().form_valid(form)
    

¿Cómo se configuran las URLs para la vista?

Es necesario configurar las URLs para que la vista esté accesible desde el navegador.

  1. Configurar urls.py:
    from django.urls import path
    from .views import ProductFormView
    
    urlpatterns = [
        path('add/', ProductFormView.as_view(), name='add_product')
    ]
    

¿Cómo se crea el template para el formulario?

El template define la estructura HTML del formulario y cómo se renderiza en la página web.

  1. Crear el template add_product.html:
    <h1>Agregar Producto</h1>
    <form method="post" enctype="multipart/form-data">
        {% csrf_token %}
        {{ form.as_p }}
        <button type="submit">Agregar</button>
    </form>
    

¿Qué es el CSRF token y por qué es importante?

El CSRF token es una medida de seguridad que protege contra ataques de tipo Cross-Site Request Forgery. Django lo incluye automáticamente en los formularios para asegurar que las solicitudes provengan de fuentes confiables.

¿Cómo se maneja la redirección después de enviar el formulario?

La redirección después del envío del formulario se maneja configurando el parámetro success_url en la vista, utilizando reverse_lazy para obtener la URL de destino.

¿Cómo se valida y guarda el producto?

Cuando el formulario es válido, el método form_valid se encarga de llamar al método save del formulario para guardar el producto en la base de datos.

Aportes 17

Preguntas 8

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Si al final les sale el error: **no such table: products\_product** Solo tienen que ejecutar: python manage.py makemigrations python manage.py migrate
Si ud llego hasta aqui y se confundio con el enrutamiento le voy a dejar una forma mas facil de entenderlo rapido y sin tanto dolor: 1. la ruta del url general siempre va a ir primero ejemplo: [`www.coffeeshop.com/products/`](https://www.coffeeshop.com/products/)` esto porque asi se puso en el include` 2. `luego viene la ruta de la aplicacion o sea lo que puso en el url de su app ejemplo: si ud puso add_product/ entonces la ruta quedaria `[`www.coffeeshop.com/products/add_product`](https://www.coffeeshop.com/products/add_product)` como vemos /products/ es como ud le llamo cuando uso el include y add_products es el nombre que le dio a la clase que renderiza su template `
1. Reto: crear una success URL que contenga un listado de todos los productos añadidos. Para empezar, lo que hice fue crear una ruta adicional en el archivo <u>products/urls.py</u>, esta la llamé "success/" `path('success/', success, name="success")` 2. Luego, creamos la vista en <u>products/views.py</u>, la llamaremos tambien success, importaremos el modelo *Products* y lo pasaremos como contexto al template **success.html.** Teniendo en cuenta que *Products* es una clase podremos acceder a todos los atributos (datos) de esta con el método all(): `def success(request): all_products = Products.objects.all()` `return render(request, 'success.html', {'products': all_products})` 3. Adicionalmente en la clase ProductFormView, actualizaremos el parametro de reverse\_lazy('nombre\_url') por reverse\_lazy('success\_o\_como\_hayas\_llamado\_la\_url') 4. Por último, creamos el archivo success.html, recorremos con un for el contexto ('products' en mi caso), y imprimimos el nombre junto con el precio: `
    ` ` {% for i in products %}` `
  1. {{i.name}} {{i.price}}
  2. ` ` {% endfor %}` `
` Y ya tendremos un resultado similar a este: ![](https://s1.gifyu.com/images/SA4dt.png) Espero te haya servido : D Saludos!
Una forma que encuentro más "directa" de ver si efectivamente se creó el producto es utilizar la shell de la base de datos, que en este caso es sqlite. Sabemos que la base de datos se llama db.sqlite3, así que ubicados en la carpeta de coffee\_shop dentro de la terminal podemos ingresar: `sqlite3 db.sqlite3` Esto nos ingresará a la shell de sqlite y allí podremos entonces listar las tablas que están en la base de datos con el comando `.tables` Y finalmente podemos hacer un `SELECT * FROM products_product;` y de esta forma vemos que efectivamente se agregó el ítem. Si queremos ver el nombre de las columnas no se nos puede olvidar ingresar el comando `.head on` Para salir y regresar a la terminal simplemente le das `.exit`. A mí se me hace más intuitiva y directa esta forma, que utilizar el ORM de Django y manipular los objetos en Python. ![](https://static.platzi.com/media/user_upload/image-a498cc28-8bd9-42ac-9ca3-e9e441d50aec.jpg)
Using the `{% csrf_token %}` template tag in Django is crucial for protecting your web application against Cross-Site Request Forgery (CSRF) attacks. CSRF attacks occur when a malicious website tricks a user's browser into making unauthorized requests to a different website where the user is authenticated. This can result in unintended actions being performed on behalf of the authenticated user. Here's why using `{% csrf_token %}` is important: ### 1. **Security** * **CSRF Protection**: The `{% csrf_token %}` tag generates a hidden input field with a CSRF token. This token is a unique, secret value that is included in both the form and the user's session. When the form is submitted, Django checks that the token in the form matches the token in the session. If they match, the request is considered valid; otherwise, it is rejected. ### 2. **Preventing Unauthorized Actions** * **User Protection**: By including the CSRF token, you ensure that only requests originating from your own site can perform actions that modify data (e.g., submitting forms, making POST requests). This prevents malicious sites from tricking users into performing actions they did not intend to. ### 3. **Maintaining Data Integrity** * **Data Integrity**: CSRF protection helps maintain the integrity of your application's data by ensuring that only legitimate requests can modify it. This is especially important for applications that handle sensitive information or perform critical actions. ### 4. **Compliance with Best Practices** * **Best Practices**: Using CSRF protection is a best practice in web development. It helps ensure that your application adheres to security standards and reduces the risk of vulnerabilities.
In Django, the `{{ form.as_p }}` template tag is used to render a form as a series of paragraphs (`

` elements), where each form field is wrapped in its own paragraph. This is a convenient way to quickly generate an HTML form without having to manually write the HTML for each field. Here's a breakdown of how it works: ### Usage When you use `{{ form.as_p }}` in a Django template, Django automatically generates the HTML for the form, including the form fields and their labels, wrapped in `

` tags. This is particularly useful for simple forms where you want a quick and easy way to render the form fields.

### What is `cleaned_data` in the `save` Method? The `cleaned_data` attribute in a Django form is a dictionary that contains the validated and "cleaned" data from the form. This data has been processed to ensure it meets the validation criteria defined in the form. The `cleaned_data` attribute is typically used in the `save` method to create or update a model instance.
### Why Use Forms in Django? 1. **Validation**: * Django forms provide a robust way to validate user input. They can enforce data types, check for required fields, and apply custom validation logic to ensure that the data meets your application's requirements. 2. **Security**: * Forms help protect against common web vulnerabilities such as cross-site scripting (XSS) and cross-site request forgery (CSRF). Django forms automatically escape output and include CSRF protection. 3. **Reusability**: * Forms can be reused across different views and templates, making your code more modular and maintainable. 4. **Ease of Use**: * Django forms simplify the process of rendering HTML forms, handling user input, and saving data to the database. They integrate seamlessly with Django's ORM and admin interface. 5. **Customization**: * Forms can be easily customized to include custom widgets, styles, and error messages, allowing you to tailor the user experience to your needs. 6. **Automatic Generation**: * Django can automatically generate forms based on your models, reducing the amount of boilerplate code you need to write.
Saben como podria mantener el autocompletado de Html y Django? instale la extension de Django que recomendo el profesor en clases anteriores pero ahora no puedo seguir con html.
Jojojojo awesome, this is the code in view.py: ```js from .models import Product class ProductList(generic.ListView): model = Product template_name = "products/list_product.html" ```Into urls.py: ```js from .views import ProductListView, ProductList urlpatterns = [ path("add/", ProductListView.as_view(), name="add_product"), path("list/", ProductList.as_view(), name="list_product"), ] ```Now in html file: ```js <html lang="en"> <head> <meta charset="UTF-8" /> <meta name="viewport" content="width=device-width, initial-scale=1.0" /> <title>Document</title> </head> <body>

Product List

{% for product in object_list %}
  • The product is {{ product.name }} - with price {{ product.price }}
  • {% endfor %} </body> </html> ```Result: ![](https://static.platzi.com/media/user_upload/image-9b09041b-95c4-46ee-995a-b91c175c7675.jpg)
    Las generic views en Django se utilizan para simplificar el manejo de tareas comunes en la web, como mostrar listas de objetos, crear, actualizar o eliminar registros. Permiten reutilizar código y reducir la cantidad de lógica que debes implementar manualmente para estas operaciones básicas.
    Yo en este punto tengo un error en mi función save de mi forms.py pero no he entendido por que ?? linea 12 Product.objects.create marca “Class ‘Product’ has no ‘objects’ member”, pude ir mas adelante en el curso pero marca error 500 al tratar de guardar el formulario y aunque ejecuta no guarda datos, como se podría resolver o que falta ?? ![](https://static.platzi.com/media/user_upload/image-4715e500-4f15-4d45-b849-f05d6cfb7b34.jpg)
    Aporte para agregar widgets al forms y darle una personalizacion como lo es con el atriubuto 'size':'50' para aumentar el tamano del input, agregar placeholder y seleccionar seleccionar el campo NumericInput para el precio asi no admite escritura en ese campo. <https://platzi.com/home/clases/9574-django/70111-creacion-de-la-aplicacion-products-con-formularios/> ```js widgets = { 'name':forms.TextInput( attrs={ 'class':'form-control {% if form.name.errors %}is-invalid{% endif %}', 'placeholder':'Galleta oreo', 'autocomplete':'off', 'size':'50' } ), 'description':forms.TextInput( attrs={ 'class':'special', 'placeholder':'Galletas', 'size':'50' } ), 'price':forms.NumberInput( attrs={ 'class':'special', 'placeholder':'5.00', } ), ```
    Si les sale error al usar el metodo save ``` def form\_valid(self, form): form.save() return super().form\_valid(form) ``` Deben cambiar este codigo en `forms.py` ``` def save(*self*): Product.objects.create( *name*=*self*.cleaned\_data\["name"], *description*=*self*.cleaned\_data\["description"], *price*=*self*.cleaned\_data\["price"], *available*=*self*.cleaned\_data\["available"], *photo*=*self*.cleaned\_data\["photo"], ) ``` Cambian los () por \[], esto porque cleaned\_data funciona como un diccionario no como una funcion
    Hola, Si queremos hacer en multiple idioma como se puede hacer? Por ejemplo para español e inglés al campo: Disponible a Available Gracias
    Por favor muestra como se puede agregar un editor de texto para poner la descripción del producto con letras coloridas, etc. por favor también como se puede agregar varios imágenes a ese producto gracias
    Un saludo a todos los auditores de este curso. ¿Alguien sabe por qué Visual Studio code no me está reconociendo a Products como una clase que está en models? (adjunto código) ![](https://static.platzi.com/media/user_upload/image-f1998e73-f6e4-4d5f-995b-4a56b7e71174.jpg)![]()