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

You don't have access to this class

Keep learning! Join and start boosting your career

Aprovecha el precio especial y haz tu profesión a prueba de IA

Antes: $249

Currency
$209
Suscríbete

Termina en:

0 Días
10 Hrs
34 Min
39 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
Resources

The forms functionality in Django allows developers to create, validate and manage forms in an efficient and organized way. Below, we will explore how to create forms in Django step by step.

How do I create forms in Django?

To create a new form in Django, you must first create a class that inherits from forms.Form. This class will contain all the fields we want to include in the form.

  1. Create the file forms.py:
    from django import formsclass ProductForm(forms.Form):name = forms.CharField(max_length=200, label='Name') description = forms.CharField(max_length=300, label='Description') price = forms.DecimalField(max_digits=10, decimal_places=2, label='Price') available = forms.BooleanField(initial=True, label='Available', required=False) photo = forms.ImageField(label='Photo', required=False)

How is the form data handled in Django?

Once the form is created, we need to define how to handle the data when the user submits the form. This includes validating the data and saving it to the database.

  1. Save method to save data:
    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'] )

How to create the view for the form?

The view connects the form with the template and handles the user request. We will use a generic Django view to simplify this process.

  1. Create the view:
    from django.views.generic.edit import FormViewfrom django.urls import reverse_lazyfrom.forms import ProductFormclass 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)

How to configure the URLs for the view?

You need to configure the URLs for the view to be accessible from the browser.

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

How is the template for the form created?

The template defines the HTML structure of the form and how it is rendered on the web page.

  1. Create the add_product.html template
    :<h1>AddProduct</h1><form method="post" enctype="multipart/form-data">{% csrf_token %} {{ form.as_p }} <button type="submit">Add</button></form>.

What is the CSRF token and why is it important?

The CSRF token is a security measure that protects against Cross-Site Request Forgery attacks. Django automatically includes it in forms to ensure that requests come from trusted sources.

How is redirection handled after form submission?

Redirection after form submission is handled by setting the success_url parameter in the view, using reverse_lazy to get the destination URL.

How is the product validated and saved?

When the form is valid, the form_valid method is in charge of calling the save method of the form to save the product in the database.

Contributions 20

Questions 9

Sort by:

Want to see more contributions, questions and answers from the community?

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 `
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)
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', } ), ```
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)
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!
Funciona bien gracias a chatgpt, ya que había que hacer más configuraciones de las esperadas para ver imágenes: ![](https://static.platzi.com/media/user_upload/upload-0f014eaa-4053-4456-9385-27f979bf60c7.png)
reto de la clase ```python class Render_product(generic.TemplateView): template_name = 'carrito/listado_compras.html' def get_context_data(self, **kwargs): context = super().get_context_data(**kwargs) context['productos'] = Product.objects.all() return context ```
Al colocar "agregar/" en el path de las URLs en Django, se define una ruta específica para que los usuarios accedan a la función correspondiente, en este caso, para agregar un producto. Este dato se puede personalizar para que sea más amigable y comprensible. Puedes usar cualquier palabra o frase que refleje la acción que el usuario realizará, como "nuevo-producto" o "crear". Es importante que la URL sea intuitiva para mejorar la experiencia del usuario. Esto se define en el archivo `urls.py` de la aplicación.
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.
    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)![]()