Subir un archivo en Django

1. Establecer el entorno de Django
2. Configurar proyecto Django
3. Probar el servidor
4. Actualizar el archivo settings.py
5. Crear un modelo
6. Crear un formulario para cargar archivos
7. Agregar vistas
8. Configurar el archivo urls.py
9. Pruebas

Este artículo lo guiará a través de cómo cargar archivos en Django. Crearemos una aplicación simple con un formulario simple para completar los detalles y seleccionar un archivo. Además, muestra todos los archivos cargados en una tabla debajo.

Antes de continuar, se recomienda crear una nueva carpeta o directorio para este proyecto para mantener las cosas organizadas.

Establecer el entorno de Django

Para este tutorial, usaremos un entorno virtual. No es obligatorio utilizar un entorno virtual, pero es una buena práctica tener un entorno virtual único para cada proyecto.

Para construir un entorno virtual, necesitamos un paquete de Python, virtualenv. Si no lo tiene en su máquina, puede descargarlo usando el siguiente comando.

pip install virtualenv

Ahora que ha instalado el paquete, creemos el entorno.

Para crear un entorno, ejecute el siguiente comando.

virtualenv environment

environment es el nombre del entorno virtual que acabamos de crear. Este entorno tendrá la versión de Python instalada globalmente en su máquina y ningún paquete excepto los predeterminados.

Para activar este entorno y usarlo, ejecute el siguiente comando.

environment\Scripts\activate

Ahora, dado que estamos aprendiendo sobre Django, necesitamos la biblioteca Django instalada. Además, dado que estamos aprendiendo a cargar archivos, necesitamos un paquete de Python adicional para manejar las imágenes. El nombre del paquete es Pillow. Instalemos todas las dependencias.

pip install django
pip install Pillow

O,

pip3 install django
pip3 install Pillow

Tenga en cuenta que en el momento de escribir este artículo, la última versión de Django es 3.2.

Configurar proyecto Django

Para configurar un proyecto Django, primero tenemos que crear un proyecto Django, crear una aplicación, registrar esa aplicación y realizar las migraciones iniciales.

Para crear un proyecto de Django, ejecute el siguiente comando.

django-admin startproject DjangoFileUpload

Ahora, cambie el directorio de trabajo a este proyecto usando el siguiente comando.

cd DjangoFileUpload

Para crear una aplicación dentro del proyecto Django, ejecute el siguiente comando.

django-admin startapp Core

O,

python manage.py startapp Core

Core es el nombre de la aplicación.

Para registrar esta aplicación, ingrese el nombre de la aplicación dentro de la lista INSTALLED_APPS en el archivo settings.py.

• settings.py

INSTALLED_APPS = [
    "django.contrib.admin",
    "django.contrib.auth",
    "django.contrib.contenttypes",
    "django.contrib.sessions",
    "django.contrib.messages",
    "django.contrib.staticfiles",
    "Core",  # Here
]

Django necesita algunos modelos para funcionar correctamente. Por ejemplo, el sistema de autenticación o el superusuario no funcionarán sin la migración inicial. Entonces, para realizar las migraciones iniciales, ejecute el siguiente comando.

python manage.py migrate

Producción :

Operations to perform:
  Apply all migrations: admin, auth, contenttypes, sessions
Running migrations:
  Applying contenttypes.0001_initial... OK
  Applying auth.0001_initial... OK
  Applying admin.0001_initial... OK
  Applying admin.0002_logentry_remove_auto_add... OK
  Applying admin.0003_logentry_add_action_flag_choices... OK
  Applying contenttypes.0002_remove_content_type_name... OK
  Applying auth.0002_alter_permission_name_max_length... OK
  Applying auth.0003_alter_user_email_max_length... OK
  Applying auth.0004_alter_user_username_opts... OK
  Applying auth.0005_alter_user_last_login_null... OK
  Applying auth.0006_require_contenttypes_0002... OK
  Applying auth.0007_alter_validators_add_error_messages... OK
  Applying auth.0008_alter_user_username_max_length... OK
  Applying auth.0009_alter_user_last_name_max_length... OK
  Applying auth.0010_alter_group_name_max_length... OK
  Applying auth.0011_update_proxy_permissions... OK
  Applying auth.0012_alter_user_first_name_max_length... OK
  Applying sessions.0001_initial... OK

Probar el servidor

Para ejecutar el servidor, use el siguiente comando. Si todo salió sin errores, debería ver su servidor Django ejecutándose en http://127.0.0.1:8000/.

python manage.py runserver

Actualizar el archivo settings.py

Los archivos cargados deben almacenarse en algún lugar. En Django, por defecto, todos los archivos cargados se almacenan en una carpeta media. Siempre puede cambiar el nombre de la carpeta y la URL asociada a ella, pero nos ceñiremos a la convención de nomenclatura predeterminada.

Para definir la URL de los archivos multimedia, MEDIA_URL, y la ruta a la carpeta multimedia, MEDIA_ROOT, agregue las siguientes declaraciones en el archivo settings.py.

• settings.py

import os

MEDIA_URL = "/media/"
MEDIA_ROOT = os.path.join(BASE_DIR, "media")

No olvide importar el módulo os. De lo contrario, Python arrojará un error.

Crear un modelo

Para almacenar los archivos cargados, tenemos que crear un modelo. El campo de este modelo contendrá la ruta al archivo cargado, pero no el archivo en sí.

Crearemos un modelo de Document para almacenar los detalles sobre los archivos cargados.

• Core\models.py

from django.db import models


class Document(models.Model):
    title = models.CharField(max_length=200)
    uploadedFile = models.FileField(upload_to="Uploaded Files/")
    dateTimeOfUpload = models.DateTimeField(auto_now=True)

El modelo tiene un campo title de un tipo de carácter para almacenar un título personalizado para el archivo cargado, y dateTimeOfUpload almacenará la fecha y hora de la carga del archivo. El campo de fecha y hora se establecerá automáticamente cuando se cree el objeto de modelo.

Para almacenar los archivos, estamos usando FileField(). Este tipo cubre todo tipo de archivos. Pero si desea ser un poco específico con las imágenes, puede utilizar ImageField() para almacenar las imágenes. Para todos los demás campos, debe ceñirse a FileField().

El parámetro upload_to se utiliza para definir la carpeta, donde los archivos de este modelo se cargarán dentro de la carpeta media.

Antes de usar este modelo, tenemos que realizar migraciones y migrarlas. Para eso, ejecute los dos siguientes comandos.

python manage.py makemigrations
python manage.py migrate

Crear un formulario para cargar archivos

Dentro de la aplicación o carpeta Core, cree una nueva carpeta, a saber, templates. Dentro de esta carpeta, cree otra carpeta, a saber, Core. Este debe ser el nombre de su aplicación. Por último, cree un nuevo archivo dentro de esta carpeta, a saber, upload-file.html.

Ahora debería tener una estructura de archivos como esta.

DjangoFileUpload /
    DjangoFileUpload /
        __init__.py
        asgi.py
        settings.py
        urls.py
        wsgi.py
    db.sqlite3
    manage.py
    Centro/
        migraciones /
        plantillas/
            Centro/
                upload-file.html
        __init__.py
        admin.py
        apps.py
        modelos.py
        tests.py
        views.py

Dentro de upload-file.html, agregue el siguiente HTML.

• Core\templates\Core\upload-file.html

<!DOCTYPE html>
{% load static %}
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Django File Upload</title>
    <style>
        @import url('https://fonts.googleapis.com/css2?family=Roboto&display=swap');

        * {
            font-family: "Roboto";
        }

        body {
            background-color: #F5F5F5;
        }

        form {
            background-color: #FFFFFF;
            padding: 25px;
        }

        table {
            width: 100%; 
            text-align: center;
            margin-top: 25px;
            padding: 25px;
            background-color: #FFFFFF;
        }

        table tr td {
            padding-top: 15px;            
        }
    </style>
</head>
<body>
    <form action="{% url 'Core:uploadFile' %}" method="POST" enctype="multipart/form-data">
        <input type="text" name="fileTitle" placeholder="Enter a title">
        <input type="file" name="uploadedFile">
        {% csrf_token %}
        <input type="submit" value="Upload">
    </form>
    <table>
        <tr>
            <th>ID</th>
            <th>Title</th>
            <th>File Path</th>
            <th>Upload Date & Time</th>
        </tr>
        {% for file in files %}
            <tr>
                <td>{{ file.id }}</td>
                <td>{{ file.title }}</td>
                <td>{{ file.uploadedFile.url }}</td>
                <td>{{ file.dateTimeOfUpload }}</td>
            </tr>
        {% endfor %}
    </table>
</body>
</html>

Dentro de la tabla, mostraremos algunos detalles sobre los archivos cargados.

Agregar vistas

Para mostrar la plantilla HTML y la información sobre ella y almacenar y manejar las cargas de archivos, crearemos una vista uploadFile().

Consulte el siguiente código

• Core\views.py

from . import models
from django.shortcuts import render


def uploadFile(request):
    if request.method == "POST":
        # Fetching the form data
        fileTitle = request.POST["fileTitle"]
        uploadedFile = request.FILES["uploadedFile"]

        # Saving the information in the database
        document = models.Document(title=fileTitle, uploadedFile=uploadedFile)
        document.save()

    documents = models.Document.objects.all()

    return render(request, "Core/upload-file.html", context={"files": documents})

Esta vista muestra la plantilla HTML que acabamos de crear en la sección anterior. El formulario de la plantilla HTML se envía a la misma URL y se gestiona en esta vista. Si el método de la solicitud es POST, obtenemos la información ingresada en el formulario y el archivo cargado, almacenamos esa información en el modelo y guardamos el modelo.

De lo contrario, en el caso general, recuperamos todos los archivos que se cargaron y los enviamos en un diccionario de contexto para mostrarlos en la plantilla HTML.

Configurar el archivo urls.py

Por último, configuremos las URL. Antes de continuar, cree un nuevo archivo, a saber, urls.py dentro de la aplicación o carpeta Core. Este archivo contendrá todas las URL asociadas con esta aplicación de Django. Es una buena práctica tener un archivo urls.py separado para cada aplicación Django.

Dentro de este archivo, agregue el siguiente código.

from . import views
from django.urls import path
from django.conf import settings
from django.conf.urls.static import static

app_name = "Core"

urlpatterns = [
    path("", views.uploadFile, name="uploadFile"),
]

if settings.DEBUG:
    urlpatterns += static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)

Hemos agregado un patrón de URL para la plantilla HTML upload-file.html. Además, hemos agregado una URL más para los archivos multimedia. Usaremos las variables constantes que declaramos en el archivo settings.py.

Como creamos un nuevo archivo urls.py dentro de la aplicación Core, tenemos que vincular las URL definidas aquí con el proyecto principal.

Para hacer eso, agregue la siguiente declaración dentro de la lista urlpatterns en DjangoFileUpload\urls.py

path("", include("Core.urls")),

Su archivo debería verse así.

Archivo: DjangoFileUpload\urls.py

from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path("admin/", admin.site.urls),
    path("", include("Core.urls")),
]

Pruebas

¡Felicidades! Ahora es el momento de probar el proyecto. Siga los pasos a continuación.

Ahora debería ver algunos detalles sobre el archivo en la tabla debajo del formulario.

Además, si revisa su directorio de trabajo, verá que se ha creado una carpeta con el nombre de medios, y dentro de esta carpeta, hay otra carpeta con el nombre de Uploaded Files. Esta carpeta contiene todos los archivos cargados.

Puede cargar fotos, videos, programas, PDF, archivos JSON, archivos HTML, etc. Tenga en cuenta que el tiempo de carga depende del tamaño del archivo, así que tenga paciencia al cargar.