• Author / Uploaded
• catolsto

Citation preview

---

Contenido Django - Inicio Django - Conceptos básicos Django - Descripción general Django - Medio ambiente Django - Creando un Proyecto Django - Ciclo de vida de las aplicaciones Django - Interfaz de administrador Django - Creando Vistas Django - Mapeo de URL Django - Sistema de plantillas Django - Modelos Django - Redirección de página Django - Envío de correos electrónicos Django - Vistas genéricas Django - Procesamiento de formularios Django - Carga de archivos Django - Configuración de Apache Django - Manejo de cookies Django - Sesiones

Django - Caché Django - Comentarios Django - RSS Django - AJAX

Django - Conceptos básicos Django es un marco web Python de alto nivel que fomenta el desarrollo rápido y el diseño limpio y pragmático. Django facilita la creación de mejores aplicaciones web de forma rápida y con menos código. Nota : Django es una marca registrada de Django Software Foundation y tiene licencia BSD.

Historia de Django 

2003 - Iniciado por Adrian Holovaty y Simon Willison como un proyecto interno en el periódico Lawrence Journal-World.



2005 - Lanzado en julio de 2005 y lo llamó Django, en honor al guitarrista de jazz Django Reinhardt.



2005 - Lo suficientemente maduro como para manejar varios sitios de alto tráfico.



Actual : Django es ahora un proyecto de código abierto con colaboradores en todo el mundo.

Django - Filosofías de diseño Django viene con las siguientes filosofías de diseño: 

Acoplado libremente : Django tiene como objetivo hacer que cada elemento de su pila sea independiente de los demás.



Menos codificación : menos código, lo que a su vez es un desarrollo rápido.



No te repitas (SECO) : todo debe desarrollarse solo en un solo lugar en lugar de repetirlo una y otra vez.



Desarrollo rápido : la filosofía de Django es hacer todo lo posible para facilitar el desarrollo hiperrápido.



Diseño limpio : Django mantiene estrictamente un diseño limpio en todo su propio código y facilita el seguimiento de las mejores prácticas de desarrollo web.

Ventajas de Django Aquí hay algunas ventajas de usar Django que se pueden enumerar aquí: 

Compatibilidad con mapeo relacional de objetos (ORM) : Django proporciona un puente entre el modelo de datos y el motor de la base de datos, y admite un gran conjunto de sistemas de bases de datos, incluidos MySQL, Oracle, Postgres, etc. Django también admite la base de datos NoSQL a través de Django-nonrel fork. Por ahora, las únicas bases de datos NoSQL compatibles son MongoDB y el motor de aplicaciones de Google.



Soporte multilingüe : Django admite sitios web multilingües a través de su sistema de internacionalización incorporado. Para que pueda desarrollar su sitio web, que admitiría varios idiomas.



Soporte de marco : Django tiene soporte incorporado para Ajax, RSS, almacenamiento en caché y varios otros marcos.



GUI de administración : Django proporciona una agradable interfaz de usuario lista para usar para actividades administrativas.



Entorno de desarrollo : Django viene con un servidor web liviano para facilitar el desarrollo y las pruebas de aplicaciones de extremo a extremo.

Django - Descripción general Como ya sabes, Django es un framework web de Python. Y como la mayoría del marco moderno, Django admite el patrón MVC. Primero veamos qué es el patrón Modelo-Vista-Controlador (MVC), y luego veremos la especificidad de Django para el patrón Modelo-Vista-Plantilla (MVT).

Patrón MVC Cuando hablamos de aplicaciones que proporcionan UI (web o escritorio), generalmente hablamos de la arquitectura MVC. Y como su nombre lo indica, el patrón MVC se basa en tres componentes: Modelo, Vista y Controlador. Consulte nuestro tutorial MVC aquí para saber más.

DJANGO MVC - Patrón MVT La plantilla de vista de modelo (MVT) es ligeramente diferente de MVC. De hecho, la principal diferencia entre los dos patrones es que Django se encarga de la parte del controlador (código de software que controla las interacciones entre el modelo y la vista), dejándonos con la plantilla. La plantilla es un archivo HTML mezclado con Django Template Language (DTL). El siguiente diagrama ilustra cómo cada uno de los componentes del patrón MVT interactúa entre sí para atender una solicitud del usuario:

Síguenos en Instagram para que estés al tanto de los nuevos libros de programación. Click aqui

www.postparaprogramadores.com /

El desarrollador proporciona el Modelo, la vista y la plantilla, luego solo lo asigna a una URL y Django hace la magia para servirlo al usuario.

Django - Medio ambiente El entorno de desarrollo de Django consiste en instalar y configurar Python, Django y un sistema de base de datos. Dado que Django se ocupa de la aplicación web, vale la pena mencionar que también necesitaría una configuración de servidor web.

Paso 1: instalación de Python Django está escrito en código Python 100% puro, por lo que deberá instalar Python en su sistema. La última versión de Django requiere Python 2.6.5 o superior para la rama 2.6.x o superior a 2.7.3 para la rama 2.7.x. Si está en una de las últimas distribuciones de Linux o Mac OS X, probablemente ya tenga instalado Python. Puede verificarlo escribiendo el comando python en el símbolo del sistema. Si ve algo como esto, se instala Python. $ python Python 2.7.5 (default, Jun 17 2014, 18:11:42) [GCC 4.8.2 20140120 (Red Hat 4.8.2-16)] on linux2

De lo contrario, puede descargar e instalar la última versión de Python desde el enlace http://www.python.org/download .

Paso 2 - Instalando Django Instalar Django es muy fácil, pero los pasos necesarios para su instalación dependen de su sistema operativo. Dado que Python es un lenguaje independiente de la plataforma, Django tiene un paquete que funciona en todas partes, independientemente de su sistema operativo. Puede descargar la última versión enlace http://www.djangoproject.com/download .

de

Django

desde

el

Instalación de UNIX / Linux y Mac OS X

Tiene dos formas de instalar Django si está ejecutando un sistema Linux o Mac OS: 

Puede usar el administrador de paquetes de su sistema operativo, o usar easy_install o pip si está instalado.



Instálelo manualmente utilizando el archivo oficial que descargó anteriormente.

Cubriremos la segunda opción, ya que la primera depende de la distribución de su sistema operativo. Si ha decidido seguir la primera opción, tenga cuidado con la versión de Django que está instalando. Digamos que obtuvo su archivo desde el enlace de arriba, debería ser algo como Django-x.xx.tar.gz: Extraer e instalar. $ tar xzvf Django-x.xx.tar.gz $ cd Django-x.xx $ sudo python setup.py install

Puede probar su instalación ejecutando este comando: $ django-admin.py --version

Si ve la versión actual de Django impresa en la pantalla, entonces todo está configurado. Nota - Para alguna versión de Django, será django-admin y se eliminará ".py". Instalación de ventanas

Asumimos que tiene su archivo Django y Python instalados en su computadora. Primero, la verificación de RUTA. En algunas versiones de Windows (Windows 7), es posible que deba asegurarse de que la variable del sistema Path tenga la ruta siguiente C:\Python27\;C:\Python27\Lib\site-packages\django\bin\, por supuesto, dependiendo de su versión de Python. Luego, extraiga e instale Django. c:\>cd c:\Django-x.xx

A continuación, instale Django ejecutando el siguiente comando para el cual necesitará privilegios administrativos en el shell de Windows "cmd": c:\Django-x.xx>python setup.py install

Para probar su instalación, abra un símbolo del sistema y escriba el siguiente comando: c:\>django-admin.py --version

Si ve la versión actual de Django impresa en la pantalla, entonces todo está configurado. O Inicie un indicador "cmd" y escriba python y luego: c:\> python

>>> import django >>> print django.get_version()

Paso 3 - Configuración de la base de datos Django admite varios motores de bases de datos principales y puede configurar cualquiera de ellos según su comodidad. 

MySQL (http://www.mysql.com/)



PostgreSQL (http://www.postgresql.org/)



SQLite 3 (http://www.sqlite.org/)



Oracle (http://www.oracle.com/)



MongoDb (https://django-mongodb-engine.readthedocs.org)



Almacén de datos de GoogleAppEngine (https://cloud.google.com/appengine/articles/django-nonrel)

Puede consultar la documentación correspondiente para instalar y configurar una base de datos de su elección. Nota - Los números 5 y 6 son bases de datos NoSQL.

Paso 4 - Servidor web Django viene con un servidor web liviano para desarrollar y probar aplicaciones. Este servidor está preconfigurado para funcionar con Django y, lo que es más importante, se reinicia cada vez que modifica el código. Sin embargo, Django admite Apache y otros servidores web populares como Lighttpd. Discutiremos ambos enfoques en los próximos capítulos mientras trabajamos con diferentes ejemplos.

Django - Creando un Proyecto Ahora que hemos instalado Django, comencemos a usarlo. En Django, cada aplicación web que desea crear se llama proyecto; y un proyecto es una suma de aplicaciones. Una aplicación es un conjunto de archivos de código que se basan en el patrón MVT. Como ejemplo, digamos que queremos construir un sitio web, el sitio web es nuestro proyecto y, el foro, las noticias, el motor de contacto son aplicaciones. Esta estructura facilita el movimiento de una aplicación entre proyectos, ya que cada aplicación es independiente.

Crear un proyecto Ya sea que esté en Windows o Linux, solo obtenga un terminal o un indicador de cmd y navegue hasta el lugar donde desea que se cree su proyecto, luego use este código: $ django-admin startproject myproject

Esto creará una carpeta "myproject" con la siguiente estructura:

myproject/ manage.py myproject/ __init__.py settings.py urls.py wsgi.py

La estructura del proyecto La carpeta "myproject" es solo el contenedor del proyecto, en realidad contiene dos elementos: 

manage.py : este archivo es una especie de django-admin local de su proyecto para interactuar con su proyecto a través de la línea de comandos (inicie el servidor de desarrollo, sincronice db ...). Para obtener una lista completa de comandos accesibles a través de manage.py, puede usar el código:

$ python manage.py help 

La subcarpeta "myproject" : esta carpeta es el paquete de Python real de su proyecto. Contiene cuatro archivos: o __init__.py : solo para Python, trate esta carpeta como un paquete. o settings.py : como su nombre indica, la configuración de tu proyecto. o urls.py : todos los enlaces de su proyecto y la función para llamar. Una

especie de ToC de tu proyecto. o wsgi.py : si necesita implementar su proyecto sobre WSGI.

Configurando su proyecto Su proyecto está configurado en la subcarpeta myproject / settings.py. Las siguientes son algunas opciones importantes que puede necesitar configurar: DEBUG = True

Esta opción le permite configurar si su proyecto está en modo de depuración o no. El modo de depuración le permite obtener más información sobre el error de su proyecto. Nunca lo configure en 'Verdadero' para un proyecto en vivo. Sin embargo, esto debe establecerse en 'Verdadero' si desea que el servidor ligero Django sirva archivos estáticos. Hazlo solo en el modo de desarrollo. DATABASES = { 'default': { 'ENGINE': 'django.db.backends.sqlite3', 'NAME': 'database.sql', 'USER': '', 'PASSWORD': '', 'HOST': '', 'PORT': '', } }

La base de datos se configura en el diccionario 'Base de datos'. El ejemplo anterior es para el motor SQLite. Como se dijo anteriormente, Django también admite: 

MySQL (django.db.backends.mysql)



PostGreSQL (django.db.backends.postgresql_psycopg2)



Oracle (django.db.backends.oracle) y NoSQL DB



MongoDB (django_mongodb_engine)

Antes de configurar cualquier motor nuevo, asegúrese de tener instalado el controlador db correcto. También puede configurar otras opciones como: TIME_ZONE, LANGUAGE_CODE, TEMPLATE ... Ahora que su proyecto está creado y configurado, asegúrese de que funcione: $ python manage.py runserver

Obtendrá algo como lo siguiente al ejecutar el código anterior: Validating models... 0 errors found September 03, 2015 - 11:41:50 Django version 1.6.11, using settings 'myproject.settings' Starting development server at http://127.0.0.1:8000/ Quit the server with CONTROL-C.

Django - Ciclo de vida de las aplicaciones Un proyecto es una suma de muchas aplicaciones. Cada aplicación tiene un objetivo y puede reutilizarse en otro proyecto, como el formulario de contacto en un sitio web puede ser una aplicación y puede reutilizarse para otros. Véalo como un módulo de su proyecto.

Crear una aplicación Asumimos que está en la carpeta de su proyecto. En nuestra carpeta principal "myproject", la misma carpeta luego manage.py $ python manage.py startapp myapp

Acaba de crear una aplicación myapp y, como proyecto, Django crea una carpeta "myapp" con la estructura de la aplicación: myapp/ __init__.py admin.py models.py tests.py views.py 

__init__.py : solo para asegurarse de que Python maneje esta carpeta como un paquete.



admin.py : este archivo te ayuda a modificar la aplicación en la interfaz de administración.



models.py : aquí se almacenan todos los modelos de aplicación.



tests.py : aquí es donde están las pruebas de tu unidad.



views.py : aquí es donde se encuentran las vistas de la aplicación.

Obtenga el proyecto para saber acerca de su aplicación En esta etapa tenemos nuestra aplicación "myapp", ahora tenemos que registrarla en nuestro proyecto Django "myproject". Para hacerlo, actualice la tupla INSTALLED_APPS en el archivo settings.py de su proyecto (agregue el nombre de su aplicación) INSTALLED_APPS = ( 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles', 'myapp', )

Django - Interfaz de administrador Django proporciona una interfaz de usuario lista para usar para actividades administrativas. Todos sabemos cómo una interfaz de administrador es importante para un proyecto web. Django genera automáticamente la interfaz de usuario de administrador en función de sus modelos de proyecto.

Inicio de la interfaz de administración La interfaz de administración depende del módulo django.countrib. Para que funcione, debe asegurarse de que algunos módulos se importen en las tuplas INSTALLED_APPS y MIDDLEWARE_CLASSES del archivo myproject / settings.py. Para INSTALLED_APPS, asegúrese de tener: INSTALLED_APPS = ( 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles', 'myapp', )

Para MIDDLEWARE_CLASSES -

MIDDLEWARE_CLASSES = ( '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', )

Antes de iniciar su servidor, para acceder a su interfaz de administración, debe iniciar la base de datos: $ python manage.py migrate

syncdb creará las tablas o colecciones necesarias según su tipo de base de datos, necesarias para que se ejecute la interfaz de administración. Incluso si no tiene un superusuario, se le pedirá que cree uno. Si ya tiene un superusuario o lo ha olvidado, siempre puede crear uno con el siguiente código: $ python manage.py createsuperuser

Ahora, para iniciar la interfaz de administración, debemos asegurarnos de haber configurado una URL para nuestra interfaz de administración. Abra myproject / url.py y debería tener algo como: from django.conf.urls import patterns, include, url from django.contrib import admin admin.autodiscover() urlpatterns = patterns('', # Examples: # url(r'^$', 'myproject.views.home', name = 'home'), # url(r'^blog/', include('blog.urls')), url(r'^admin/', include(admin.site.urls)), )

Ahora solo ejecuta el servidor. $ python manage.py runserver

Y su interfaz de administrador es accesible en: http://127.0.0.1:8000/admin/

Una vez conectado con su cuenta de superusuario, verá la siguiente pantalla:

Esa interfaz le permitirá administrar grupos y usuarios de Django, y todos los modelos registrados en su aplicación. La interfaz le brinda la capacidad de realizar al menos las operaciones "CRUD" (Crear, Leer, Actualizar, Eliminar) en sus modelos.

Django - Creando Vistas Una función de vista, o "vista" para abreviar, es simplemente una función de Python que toma una solicitud web y devuelve una respuesta web. Esta respuesta puede ser el contenido HTML de una página web, o una redirección, o un error 404, o un documento XML, o una imagen, etc. Ejemplo: usa la vista para crear páginas web, tenga en cuenta que necesita asociar una vista a una URL para verlo como una página web. En Django, las vistas deben crearse en el archivo views.py de la aplicación.

Vista simple Crearemos una vista simple en myapp para decir "¡Bienvenido a mi aplicación!" Ver la siguiente vista: from django.http import HttpResponse def hello(request): text = """welcome to my app !""" return HttpResponse(text)

En esta vista, usamos HttpResponse para renderizar el HTML (como probablemente haya notado, tenemos el HTML codificado en la vista). Para ver esta vista como una página, solo necesitamos asignarla a una URL (esto se discutirá en un próximo capítulo). Usamos HttpResponse para representar el HTML en la vista anterior. Esta no es la mejor manera de renderizar páginas. Django admite el patrón MVT, por lo que para hacer la vista precedente, Django, como MVT, necesitaremos: Una plantilla: myapp / templates / hello.html Y ahora nuestra vista se verá así: from django.shortcuts import render def hello(request): return render(request, "myapp/template/hello.html", {})

Las vistas también pueden aceptar parámetros: from django.http import HttpResponse def hello(request, number): text = "welcome to my app number %s!"% number return HttpResponse(text)

Cuando se vincula a una URL, la página mostrará el número pasado como parámetro. Tenga en cuenta que los parámetros se pasarán a través de la URL (discutido en el próximo capítulo).

Django - Mapeo de URL Ahora que tenemos una vista de trabajo como se explicó en los capítulos anteriores. Queremos acceder a esa vista a través de una URL. Django tiene su propia forma de mapeo de URL y se realiza editando el archivo url.py de su proyecto (myproject / url.py) . El archivo url.py se ve así: from django.conf.urls import patterns, include, url from django.contrib import admin admin.autodiscover() urlpatterns = patterns('', #Examples

#url(r'^$', 'myproject.view.home', name = 'home'), #url(r'^blog/', include('blog.urls')), url(r'^admin', include(admin.site.urls)), )

Cuando un usuario solicita una página en su aplicación web, el controlador Django se hace cargo de buscar la vista correspondiente a través del archivo url.py y luego devuelve la respuesta HTML o un error 404 no encontrado, si no se encuentra. En url.py, lo más importante es la tupla "urlpatterns" . Es donde define la asignación entre URL y vistas. Una asignación es una tupla en patrones de URL como from django.conf.urls import patterns, include, url from django.contrib import admin admin.autodiscover() urlpatterns = patterns('', #Examples #url(r'^$', 'myproject.view.home', name = 'home'), #url(r'^blog/', include('blog.urls')), url(r'^admin', include(admin.site.urls)), url(r'^hello/', 'myapp.views.hello', name = 'hello'), )

La línea marcada asigna la URL "/ home" a la vista de saludo creada en el archivo myapp / view.py. Como puede ver arriba, un mapeo se compone de tres elementos: 

El patrón : una expresión regular que coincide con la URL que desea resolver y asignar. Todo lo que puede funcionar con el módulo 're' de python es elegible para el patrón (útil cuando desea pasar parámetros a través de url).



La ruta de Python a la vista : igual que cuando está importando un módulo.



El nombre : para realizar la inversión de URL, deberá usar patrones de URL con nombre como se hizo en los ejemplos anteriores. Una vez hecho esto, simplemente inicie el servidor para acceder a su vista a través de: http: //127.0.0.1/hello

Organizando tus URL Hasta ahora, hemos creado las URL en el archivo "myprojects / url.py", sin embargo, como se dijo anteriormente sobre Django y la creación de una aplicación, el mejor punto era poder reutilizar aplicaciones en diferentes proyectos. Puede ver fácilmente cuál es el problema, si está guardando todas sus URL en el archivo "projecturl.py". Por lo tanto, la mejor práctica es crear un "url.py" por aplicación e incluirlo en el archivo url.py de nuestros proyectos principales (incluimos URL de administrador para la interfaz de administrador antes).

Como se hace Necesitamos crear un archivo url.py en myapp usando el siguiente código: from django.conf.urls import patterns, include, url urlpatterns = patterns('', url(r'^hello/', 'myapp.views.hello', name = 'hello'),)

Entonces myproject / url.py cambiará a lo siguiente: from django.conf.urls import patterns, include, url from django.contrib import admin admin.autodiscover() urlpatterns = patterns('', #Examples #url(r'^$', 'myproject.view.home', name = 'home'), #url(r'^blog/', include('blog.urls')), url(r'^admin', include(admin.site.urls)), url(r'^myapp/', include('myapp.urls')), )

Hemos incluido todas las URL de la aplicación myapp. El home.html al que se accedió a través de "/ hello" ahora es "/ myapp / hello", que es una estructura mejor y más comprensible para la aplicación web.

Ahora imaginemos que tenemos otra vista en myapp "morning" y queremos mapearla en myapp / url.py, luego cambiaremos nuestro myapp / url.py a from django.conf.urls import patterns, include, url urlpatterns = patterns('', url(r'^hello/', 'myapp.views.hello', name = 'hello'), url(r'^morning/', 'myapp.views.morning', name = 'morning'), )

Esto se puede refactorizar para: from django.conf.urls import patterns, include, url urlpatterns = patterns('myapp.views', url(r'^hello/', 'hello', name = 'hello'), url(r'^morning/', 'morning', name = 'morning'),)

Como puede ver, ahora usamos el primer elemento de nuestra tupla urlpatterns . Esto puede ser útil cuando desea cambiar el nombre de su aplicación.

Envío de parámetros a vistas Ahora sabemos cómo mapear URL, cómo organizarlas, ahora veamos cómo enviar parámetros a las vistas. Una muestra clásica es el ejemplo del artículo (desea acceder a un artículo a través de "/ articles / article_id"). El paso de parámetros se realiza al capturarlos con la expresión regular en el patrón de URL. Si tenemos una vista como la siguiente en "myapp / view.py" from django.shortcuts import render from django.http import HttpResponse def hello(request): return render(request, "hello.html", {}) def viewArticle(request, articleId): text = "Displaying article Number : %s"%articleId return HttpResponse(text)

Queremos mapearlo en myapp / url.py para poder acceder a él a través de "/ myapp / article / articleId", necesitamos lo siguiente en "myapp / url.py" from django.conf.urls import patterns, include, url

urlpatterns = patterns('myapp.views', url(r'^hello/', 'hello', name = 'hello'), url(r'^morning/', 'morning', name = 'morning'), url(r'^article/(\d+)/', 'viewArticle', name = 'article'),)

Cuando Django vea la url: "/ myapp / article / 42", pasará los parámetros '42' a la vista Vista de artículo, y en su navegador debería obtener el siguiente resultado:

Tenga en cuenta que el orden de los parámetros es importante aquí. Supongamos que queremos la lista de artículos de un mes del año, agreguemos una vista Vista de artículos. Nuestra view.py se convierte en from django.shortcuts import render from django.http import HttpResponse def hello(request): return render(request, "hello.html", {}) def viewArticle(request, articleId): text = "Displaying article Number : %s"%articleId return HttpResponse(text) def viewArticles(request, month, year): text = "Displaying articles of : %s/%s"%(year, month) return HttpResponse(text)

El archivo url.py correspondiente se verá así: from django.conf.urls import patterns, include, url urlpatterns = patterns('myapp.views', url(r'^hello/', 'hello', name = 'hello'), url(r'^morning/', 'morning', name = 'morning'), url(r'^article/(\d+)/', 'viewArticle', name = 'article'), url(r'^articles/(\d{2})/(\d{4})', 'viewArticles', name = 'articles'),)

Ahora, cuando vaya a “/ myapp / articles / 12/2006 /” obtendrá 'Visualización de artículos de: 2006/12' pero si invierte los parámetros no obtendrá el mismo resultado.

Para evitar eso, es posible vincular un parámetro de URL al parámetro de vista. Para eso, nuestro url.py se convertirá en from django.conf.urls import patterns, include, url urlpatterns = patterns('myapp.views', url(r'^hello/', 'hello', name = 'hello'), url(r'^morning/', 'morning', name = 'morning'), url(r'^article/(\d+)/', 'viewArticle', name = 'article'), url(r'^articles/(?P\d{2})/(?P\d{4})', 'viewArticles', name = 'articles'),)

Django - Sistema de plantillas Django hace posible separar Python y HTML, Python va en vistas y HTML va en plantillas. Para vincular los dos, Django se basa en la función de renderizado y el lenguaje de plantillas de Django.

La función de renderizado Esta función toma tres parámetros: 

Solicitud : la solicitud inicial.



La ruta a la plantilla : esta es la ruta relativa a la opción TEMPLATE_DIRS en las variables settings.py del proyecto.



Diccionario de parámetros : un diccionario que contiene todas las variables necesarias en la plantilla. Esta variable se puede crear o puede usar locales () para pasar todas las variables locales declaradas en la vista.

Lenguaje de plantilla Django (DTL) El motor de plantillas de Django ofrece un mini lenguaje para definir la capa de la aplicación orientada al usuario.

Mostrar variables

Una variable se ve así: {{variable}}. La plantilla reemplaza la variable por la variable enviada por la vista en el tercer parámetro de la función de representación. Cambiemos nuestro hello.html para mostrar la fecha de hoy: hola.html

Hello World!!!

Today is {{today}}

Entonces nuestra opinión cambiará a def hello(request): today = datetime.datetime.now().date() return render(request, "hello.html", {"today" : today})

Ahora obtendremos el siguiente resultado después de acceder a la URL / myapp / hello: Hello World!!! Today is Sept. 11, 2015

Como probablemente haya notado, si la variable no es una cadena, Django usará el método __str__ para mostrarla; y con el mismo principio puedes acceder a un atributo de objeto tal como lo haces en Python. Por ejemplo: si quisiéramos mostrar la fecha año, mi variable sería: {{today.year}}.

Filtros Le ayudan a modificar variables en el tiempo de visualización. La estructura de los filtros tiene el siguiente aspecto: {{var | filters}}. Algunos ejemplos 

{{string | truncatewords: 80}} : este filtro truncará la cadena, por lo que solo verá las primeras 80 palabras.



{{string | lower}} - Convierte la cadena en minúsculas.



{{string | escape | linebreaks}} : escapa del contenido de la cadena y luego convierte los saltos de línea en etiquetas.

También puede establecer el valor predeterminado para una variable.

Etiquetas Etiquetas le permite realizar las siguientes operaciones: si condición, para bucle, herencia de plantilla y más.

Etiqueta si

Al igual que en Python, puede usar if, else y elif en su plantilla:

Hello World!!!

Today is {{today}}

We are {% if today.day == 1 %} the first day of month. {% elif today.day == 30 %} the last day of month. {% else %} I don't know. {%endif%}

En esta nueva plantilla, dependiendo de la fecha del día, la plantilla representará un cierto valor. Etiqueta para

Al igual que 'if', tenemos la etiqueta 'for', que funciona exactamente como en Python. Cambiemos nuestra vista de saludo para transmitir una lista a nuestra plantilla: def hello(request): today = datetime.datetime.now().date() daysOfWeek = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun'] return render(request, "hello.html", {"today" : today, "days_of_week" : daysOfWeek})

La plantilla para mostrar esa lista usando {{for}}

Hello World!!!

Today is {{today}}

We are {% if today.day == 1 %} the first day of month. {% elif today.day == 30 %} the last day of month. {% else %} I don't know.

{%endif%}

{% for day in days_of_week %} {{day}}

{% endfor %}

Y deberíamos obtener algo como: Hello World!!! Today is Sept. 11, 2015 We are I don't know. Mon Tue Wed Thu Fri Sat Sun Bloquear y extender etiquetas

Un sistema de plantillas no puede completarse sin herencia de plantillas. Es decir, cuando diseñe sus plantillas, debe tener una plantilla principal con agujeros que la plantilla del niño llenará de acuerdo con sus propias necesidades, como una página puede necesitar un CSS especial para la pestaña seleccionada. Cambiemos la plantilla hello.html para heredar de main_template.html. main_template.html

{% block title %}Page Title{% endblock %}

{% block content %} Body content {% endblock %}

hola.html

{% extends "main_template.html" %} {% block title %}My Hello Page{% endblock %} {% block content %} Hello World!!!

Today is {{today}}

We are {% if today.day == 1 %} the first day of month. {% elif today.day == 30 %} the last day of month. {% else %} I don't know. {%endif%}

{% for day in days_of_week %} {{day}}

{% endfor %} {% endblock %}

En el ejemplo anterior, al llamar a / myapp / hello todavía obtendremos el mismo resultado que antes, pero ahora confiamos en las extensiones y el bloqueo para refactorizar nuestro código: En main_template.html definimos bloques usando el bloque de etiqueta. El bloque de título contendrá el título de la página y el bloque de contenido tendrá el contenido principal de la página. En home.html utilizamos extensiones para heredar de main_template.html, luego rellenamos el bloque definido anteriormente (contenido y título). Etiqueta de comentario

La etiqueta de comentario ayuda a definir comentarios en plantillas, no comentarios HTML, no aparecerán en la página HTML. Puede ser útil para la documentación o simplemente comentar una línea de código.

Django - Modelos Un modelo es una clase que representa una tabla o colección en nuestra base de datos, y donde cada atributo de la clase es un campo de la tabla o colección. Los modelos se definen en la aplicación / models.py (en nuestro ejemplo: myapp / models.py)

Creando un modelo El siguiente es un modelo de Dreamreal creado como ejemplo: from django.db import models

class Dreamreal(models.Model): website = models.CharField(max_length = 50) mail = models.CharField(max_length = 50) name = models.CharField(max_length = 50) phonenumber = models.IntegerField() class Meta: db_table = "dreamreal"

Cada modelo hereda de django.db.models.Model. Nuestra clase tiene 4 atributos (3 CharField y 1 Integer), esos serán los campos de la tabla. La clase Meta con el atributo db_table nos permite definir la tabla real o el nombre de la colección. Django nombra la tabla o colección automáticamente: myapp_modelName. Esta clase te permitirá forzar el nombre de la tabla a lo que quieras. Hay más tipos de campos en django.db.models, puede obtener más información sobre ellos en https://docs.djangoproject.com/en/1.5/ref/models/fields/#field-types Después de crear su modelo, necesitará Django para generar la base de datos real: $python manage.py syncdb Datos de manipulación (CRUD)

Creemos una vista "crudops" para ver cómo podemos hacer operaciones CRUD en modelos. Nuestro myapp / views.py se verá así: myapp / views.py from myapp.models import Dreamreal from django.http import HttpResponse def crudops(request): #Creating an entry dreamreal = Dreamreal( website = "www.polo.com", mail = "[email protected]", name = "sorex", phonenumber = "002376970" ) dreamreal.save() #Read ALL entries objects = Dreamreal.objects.all() res ='Printing all Dreamreal entries in the DB :
' for elt in objects: res += elt.name+"
" #Read a specific entry: sorex = Dreamreal.objects.get(name = "sorex")

res += 'Printing One entry
' res += sorex.name #Delete an entry res += '
Deleting an entry
' sorex.delete() #Update dreamreal = Dreamreal( website = "www.polo.com", mail = "[email protected]", name = "sorex", phonenumber = "002376970" ) dreamreal.save() res += 'Updating entry
' dreamreal = Dreamreal.objects.get(name = 'sorex') dreamreal.name = 'thierry' dreamreal.save() return HttpResponse(res) Otra manipulación de datos

Exploremos otras manipulaciones que podemos hacer en Modelos. Tenga en cuenta que las operaciones CRUD se realizaron en instancias de nuestro modelo, ahora trabajaremos directamente con la clase que representa nuestro modelo. Creemos una vista de 'manipulación de datos' en myapp / views.py from myapp.models import Dreamreal from django.http import HttpResponse def datamanipulation(request): res = '' #Filtering data: qs = Dreamreal.objects.filter(name = "paul") res += "Found : %s results
"%len(qs) #Ordering results qs = Dreamreal.objects.order_by("name") for elt in qs: res += elt.name + '
' return HttpResponse(res)

Vinculación de modelos Django ORM ofrece 3 formas de vincular modelos:

Uno de los primeros casos que veremos aquí son las relaciones uno a muchos. Como puede ver en el ejemplo anterior, la compañía Dreamreal puede tener múltiples sitios web en línea. La definición de esa relación se realiza mediante django.db.models.ForeignKey myapp / models.py from django.db import models class Dreamreal(models.Model): website = models.CharField(max_length = 50) mail = models.CharField(max_length = 50) name = models.CharField(max_length = 50) phonenumber = models.IntegerField() online = models.ForeignKey('Online', default = 1) class Meta: db_table = "dreamreal" class Online(models.Model): domain = models.CharField(max_length = 30) class Meta: db_table = "online"

Como puede ver en nuestro myapp / models.py actualizado, agregamos el modelo en línea y lo vinculamos a nuestro modelo Dreamreal. Veamos cómo funciona todo esto a través de manage.py shell: Primero, creemos algunas compañías (entradas de Dreamreal) para probar en nuestro shell Django: $python manage.py shell >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>>

from myapp.models import Dreamreal, Online dr1 = Dreamreal() dr1.website = 'company1.com' dr1.name = 'company1' dr1.mail = 'contact@company1' dr1.phonenumber = '12345' dr1.save() dr2 = Dreamreal() dr1.website = 'company2.com' dr2.website = 'company2.com' dr2.name = 'company2' dr2.mail = 'contact@company2' dr2.phonenumber = '56789' dr2.save()

Ahora algunos dominios alojados: >>> on1 = Online() >>> on1.company = dr1 >>> on1.domain = "site1.com"

>>> >>> >>> >>> >>> >>> >>> >>> >>> >>>

on2 = Online() on2.company = dr1 on2.domain = "site2.com" on3 = Online() on3.domain = "site3.com" dr2 = Dreamreal.objects.all()[2] on3.company = dr2 on1.save() on2.save() on3.save()

Acceder al atributo de la empresa de alojamiento (entrada de Dreamreal) desde un dominio en línea es simple: >>> on1.company.name

Y si queremos conocer todo el dominio en línea alojado por una empresa en Dreamreal, utilizaremos el código: >>> dr1.online_set.all()

Para obtener un QuerySet, tenga en cuenta que todos los métodos de manipulación que hemos visto antes (filter, all, exclude, order_by ....) También puede acceder a los atributos del modelo vinculado para las operaciones de filtrado, supongamos que desea obtener todos los dominios en línea donde el nombre de Dreamreal contiene 'empresa': >>> Online.objects.filter(company__name__contains = 'company'

Nota : ese tipo de consulta solo es compatible con SQL DB. No funcionará para bases de datos no relacionales donde las uniones no existen y hay dos '_'. Pero esa no es la única forma de vincular modelos, también tiene OneToOneField, un enlace que garantiza que la relación entre dos objetos es única. Si utilizamos OneToOneField en nuestro ejemplo anterior, eso significaría que para cada entrada de Dreamreal solo es posible una entrada en línea y, por el contrario, lo es. Y el último, ManyToManyField para (nn) relación entre tablas. Tenga en cuenta que esos son relevantes para DB basado en SQL.

Django - Redirección de página La redirección de página es necesaria por muchas razones en la aplicación web. Es posible que desee redirigir a un usuario a otra página cuando se produce una acción específica, o básicamente en caso de error. Por ejemplo, cuando un usuario inicia sesión en su sitio web, a menudo se lo redirige a la página de inicio principal o a su tablero personal. En Django, la redirección se realiza utilizando el método de 'redirección'. El método de 'redirección' toma como argumento: la URL a la que desea ser redirigido como el nombre de la vista de la cadena A. El myapp / views se parece a lo siguiente hasta ahora: def hello(request): today = datetime.datetime.now().date()

daysOfWeek = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun'] return render(request, "hello.html", {"today" : today, "days_of_week" : daysOfWeek}) def viewArticle(request, articleId): """ A view that display an article based on his ID""" text = "Displaying article Number : %s" %articleId return HttpResponse(text) def viewArticles(request, year, month): text = "Displaying articles of : %s/%s"%(year, month) return HttpResponse(text)

Cambiemos la vista de saludo para redirigir a djangoproject.com y nuestro viewArticle para redirigir a nuestros '/ myapp / articles' internos. Para hacerlo, myapp / view.py cambiará a from django.shortcuts import render, redirect from django.http import HttpResponse import datetime # Create your views here. def hello(request): today = datetime.datetime.now().date() daysOfWeek = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun'] return redirect("https://www.djangoproject.com") def viewArticle(request, articleId): """ A view that display an article based on his ID""" text = "Displaying article Number : %s" %articleId return redirect(viewArticles, year = "2045", month = "02") def viewArticles(request, year, month): text = "Displaying articles of : %s/%s"%(year, month) return HttpResponse(text)

En el ejemplo anterior, primero importamos el redireccionamiento desde django.shortcuts y para el redireccionamiento al sitio web oficial de Django simplemente pasamos la URL completa al método 'redirect' como cadena, y para el segundo ejemplo (la vista viewArticle) el 'redirect' El método toma el nombre de la vista y sus parámetros como argumentos. Al acceder a / myapp / hello, aparecerá la siguiente pantalla:

Y al acceder a / myapp / article / 42, aparecerá la siguiente pantalla:

También es posible especificar si la 'redirección' es temporal o permanente agregando el parámetro permanente = Verdadero. El usuario no verá ninguna diferencia, pero estos son detalles que los motores de búsqueda tienen en cuenta al clasificar su sitio web. También recuerde el parámetro 'nombre' que definimos en nuestro url.py al mapear las URL: url(r'^articles/(?P\d{2})/(?P\d{4})/', 'viewArticles', name = 'articles'),

Ese nombre (aquí artículo) se puede usar como argumento para el método de 'redirección', luego nuestra vista La redirección del artículo se puede cambiar de def viewArticle(request, articleId): """ A view that display an article based on his ID""" text = "Displaying article Number : %s" %articleId return redirect(viewArticles, year = "2045", month = "02")

Adef viewArticle(request, articleId): """ A view that display an article based on his ID""" text = "Displaying article Number : %s" %articleId return redirect(articles, year = "2045", month = "02")

Nota : también hay una función para generar URL; se usa de la misma manera que la redirección; El método 'inverso' (django.core.urlresolvers.reverse). Esta función no devuelve un objeto HttpResponseRedirect, sino simplemente una cadena que contiene la URL de la vista compilada con cualquier argumento pasado.

Django - Envío de correos electrónicos Django viene con un motor liviano listo y fácil de usar para enviar correos electrónicos. Similar a Python, solo necesita una importación de smtplib. En Django solo necesitas importar django.core.mail. Para comenzar a enviar correos electrónicos, edite el archivo settings.py del proyecto y configure las siguientes opciones: 

EMAIL_HOST : servidor smtp.



EMAIL_HOST_USER : credencial de inicio de sesión para el servidor smtp.



EMAIL_HOST_PASSWORD : credencial de contraseña para el servidor smtp.



EMAIL_PORT : puerto del servidor smtp.



EMAIL_USE_TLS o _SSL : verdadero si la conexión es segura.

Enviar un correo electrónico simple Creemos una vista "sendSimpleEmail" para enviar un correo electrónico simple. from django.core.mail import send_mail from django.http import HttpResponse def sendSimpleEmail(request,emailto): res = send_mail("hello paul", "comment tu vas?", "[email protected]", [emailto]) return HttpResponse('%s'%res)

Aquí están los detalles de los parámetros de send_mail: 

asunto : asunto del correo electrónico.



mensaje : cuerpo del correo electrónico.



from_email - Correo electrónico de.



destinatario_lista - Lista de la dirección de correo electrónico de los destinatarios.



fail_silently - Bool, si falso send_mail generará una excepción en caso de error.



auth_user : inicio de sesión del usuario si no está configurado en settings.py.



auth_password : contraseña de usuario si no está configurada en settings.py.



conexión : backend de correo electrónico.



html_message : (nuevo en Django 1.7) si está presente, el correo electrónico será multiparte / alternativo.

Creemos una URL para acceder a nuestra vista: from django.conf.urls import patterns, url urlpatterns = paterns('myapp.views', url(r'^simpleemail/(?P [\w.%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,4})/', 'sendSimpleEmail' , name = 'sendSimpleEmail'),)

Entonces, al acceder a /myapp/simpleemail/[email protected], obtendrá la siguiente página:

Envío de múltiples correos con send_mass_mail El método devuelve el número de mensajes entregados con éxito. Esto es lo mismo que send_mail pero toma un parámetro adicional; datatuple, nuestra vista sendMassEmail será entonces: from django.core.mail import send_mass_mail from django.http import HttpResponse def sendMassEmail(request,emailto): msg1 = ('subject 1', 'message 1', '[email protected]', [emailto1]) msg2 = ('subject 2', 'message 2', '[email protected]', [emailto2]) res = send_mass_mail((msg1, msg2), fail_silently = False) return HttpResponse('%s'%res)

Creemos una URL para acceder a nuestra vista: from django.conf.urls import patterns, url urlpatterns = paterns('myapp.views', url(r'^massEmail/(?P [\w.%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,4})/(?P [\w.%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,4})', 'sendMassEmail' , name = 'sendMassEmail'),)

Al acceder a /myapp/massemail/[email protected]/[email protected]/, obtenemos:

Los detalles de los parámetros de send_mass_mail son: 

datatuples : una tupla en la que cada elemento es similar (asunto, mensaje, correo electrónico, lista de destinatarios).



fail_silently - Bool, si falso send_mail generará una excepción en caso de error.



auth_user : inicio de sesión del usuario si no está configurado en settings.py.



auth_password : contraseña de usuario si no está configurada en settings.py.



conexión : backend de correo electrónico.

Como puede ver en la imagen de arriba, se enviaron dos mensajes con éxito. Nota : en este ejemplo, estamos usando Python smtp debuggingserver, que puede iniciar usando $python -m smtpd -n -c DebuggingServer localhost:1025

Esto significa que todos sus correos electrónicos enviados se imprimirán en stdout y el servidor ficticio se está ejecutando en localhost: 1025. Envío de correos electrónicos a administradores y gerentes usando los métodos mail_admins y mail_managers Estos métodos envían correos electrónicos a los administradores del sitio como se define en la opción ADMINS del archivo settings.py, y a los administradores del sitio como se define en la opción ADMINISTRADORES del archivo settings.py. Supongamos que nuestras opciones ADMINS y MANAGERS se ven así: ADMINS = (('polo', '[email protected]'),) GERENTES = (('popoli', '[email protected]'),) from django.core.mail import mail_admins from django.http import HttpResponse def sendAdminsEmail(request): res = mail_admins('my subject', 'site is going down.') return HttpResponse('%s'%res)

El código anterior enviará un correo electrónico a cada administrador definido en la sección ADMINS. from django.core.mail import mail_managers from django.http import HttpResponse def sendManagersEmail(request): res = mail_managers('my subject 2', 'Change date on the site.') return HttpResponse('%s'%res)

El código anterior enviará un correo electrónico a cada gerente definido en la sección GERENTES. Detalles de los parámetros 

Asunto : asunto del correo electrónico.



mensaje : cuerpo del correo electrónico.



fail_silently - Bool, si falso send_mail generará una excepción en caso de error.



conexión : backend de correo electrónico.



html_message : (nuevo en Django 1.7) si está presente, el correo electrónico será multiparte / alternativo.

Envío de correo electrónico HTML Enviar un mensaje HTML en Django> = 1.7 es tan fácil como: from django.core.mail import send_mail from django.http import HttpResponse res = send_mail("hello paul", "comment tu vas?", "[email protected]", ["[email protected]"], html_message=")

Esto generará un correo electrónico multiparte / alternativo. Pero para Django >> import django.views.generic >>> dir(django.views.generic) ['ArchiveIndexView', 'CreateView', 'DateDetailView', 'DayArchiveView', 'DeleteView', 'DetailView', 'FormView', 'GenericViewError', 'ListView', 'MonthArchiveView', 'RedirectView', 'TemplateView', 'TodayArchiveView', 'UpdateView', 'View', 'WeekArchiveView', 'YearArchiveView', '__builtins__', '__doc__', '__file__', '__name__', '__package__', '__path__', 'base', 'dates', 'detail', 'edit', 'list']

Esto puede usarlo para su vista genérica. Veamos algún ejemplo para ver cómo funciona.

Páginas Estáticas Publiquemos una página estática desde la plantilla "static.html". Nuestro static.html

This is a static page!!!

Si lo hiciéramos de la manera que aprendimos antes, tendríamos que cambiar myapp / views.py para que sea -

from django.shortcuts import render def static(request): return render(request, 'static.html', {})

y myapp / urls.py para ser from django.conf.urls import patterns, url urlpatterns = patterns("myapp.views", url(r'^static/', 'static', name = 'static'),)

La mejor manera es usar vistas genéricas. Para eso, nuestro myapp / views.py se convertirá en from django.views.generic import TemplateView class StaticView(TemplateView): template_name = "static.html"

Y nuestro myapp / urls.py estaremos from myapp.views import StaticView from django.conf.urls import patterns urlpatterns = patterns("myapp.views", (r'^static/$', StaticView.as_view()),)

Al acceder a / myapp / static, obtienes:

Para el mismo resultado también podemos hacer lo siguiente: 

No hay cambios en las vistas.py



Cambie el archivo url.py para que sea -

from django.views.generic import TemplateView from django.conf.urls import patterns, url urlpatterns = patterns("myapp.views", url(r'^static/',TemplateView.as_view(template_name = 'static.html')),)

Como puede ver, solo necesita cambiar el archivo url.py en el segundo método.

Listar y mostrar datos de la base de datos

Vamos a enumerar todas las entradas en nuestro modelo Dreamreal. Hacerlo es fácil usando la clase de vista genérica ListView. Edite el archivo url.py y actualícelo como from django.views.generic import ListView from django.conf.urls import patterns, url urlpatterns = patterns( "myapp.views", url(r'^dreamreals/', ListView.as_view(model = Dreamreal, template_name = "dreamreal_list.html")), )

Es importante tener en cuenta en este punto que la variable que pasa la vista genérica a la plantilla es object_list. Si desea nombrarlo usted mismo, deberá agregar un argumento context_object_name al método as_view. Entonces el url.py se convertirá en from django.views.generic import ListView from django.conf.urls import patterns, url urlpatterns = patterns("myapp.views", url(r'^dreamreals/', ListView.as_view( template_name = "dreamreal_list.html")), model = Dreamreal, context_object_name = ”dreamreals_objects” ,)

La plantilla asociada será entonces: {% extends "main_template.html" %} {% block content %} Dreamreals:

{% for dr in object_list %} {{dr.name}}

{% endfor %} {% endblock %}

Acceder a / myapp / dreamreals / producirá la siguiente página:

Django - Procesamiento de formularios Crear formularios en Django es realmente similar a crear un modelo. Aquí nuevamente, solo necesitamos heredar de la clase Django y los atributos de la clase serán los campos del formulario. Agreguemos un archivo forms.py en la carpeta myapp para contener nuestros formularios de aplicación. Crearemos un formulario de inicio de sesión. myapp / forms.py #-*- coding: utf-8 -*from django import forms class LoginForm(forms.Form): user = forms.CharField(max_length = 100) password = forms.CharField(widget = forms.PasswordInput())

Como se vio anteriormente, el tipo de campo puede tomar el argumento "widget" para la representación html; en nuestro caso, queremos que la contraseña se oculte, no se muestre. Muchos otros widgets están presentes en Django: DateInput para fechas, CheckboxInput para casillas de verificación, etc.

Usar formulario en una vista Hay dos tipos de solicitudes HTTP, GET y POST. En Django, el objeto de solicitud pasado como parámetro a su vista tiene un atributo llamado "método" donde se establece el tipo de solicitud, y se puede acceder a todos los datos pasados a través de POST a través del diccionario request.POST. Creemos una vista de inicio de sesión en nuestro myapp / views.py #-*- coding: utf-8 -*from myapp.forms import LoginForm def login(request):

username = "not logged in" if request.method == "POST": #Get the posted form MyLoginForm = LoginForm(request.POST) if MyLoginForm.is_valid(): username = MyLoginForm.cleaned_data['username'] else: MyLoginForm = Loginform() return render(request, 'loggedin.html', {"username" : username})

La vista mostrará el resultado del formulario de inicio de sesión publicado a través del loginin.html . Para probarlo, primero necesitaremos la plantilla de formulario de inicio de sesión. Llamémoslo login.html.

{% csrf_token %}











Login





La plantilla mostrará un formulario de inicio de sesión y publicará el resultado en nuestra vista de inicio de sesión anterior. Probablemente haya notado la etiqueta en la plantilla, que es solo para evitar el ataque de falsificación de solicitudes entre sitios (CSRF) en su sitio. {% csrf_token %}

Una vez que tengamos la plantilla de inicio de sesión, necesitamos la plantilla loginin.html que se mostrará después del tratamiento del formulario.

You are : {{username}}

Ahora, solo necesitamos nuestro par de URL para comenzar: myapp / urls.py from django.conf.urls import patterns, url from django.views.generic import TemplateView urlpatterns = patterns('myapp.views', url(r'^connection/',TemplateView.as_view(template_name = 'login.html')), url(r'^login/', 'login', name = 'login'))

Al acceder a "/ myapp / connection", obtendremos la siguiente plantilla login.html:

En la publicación del formulario, el formulario es válido. En nuestro caso, asegúrese de completar los dos campos y obtendrá:

En caso de que su nombre de usuario sea polo, y haya olvidado la contraseña. Recibirá el siguiente mensaje:

Uso de nuestra propia validación de formularios

En el ejemplo anterior, al validar el formulario: MyLoginForm.is_valid()

Solo usamos el motor de validación de forma automática Django, en nuestro caso solo nos aseguramos de que los campos sean obligatorios. Ahora intentemos asegurarnos de que el usuario que intenta iniciar sesión esté presente en nuestra base de datos como entrada de Dreamreal. Para esto, cambie myapp / forms.py a #-*- coding: utf-8 -*from django import forms from myapp.models import Dreamreal class LoginForm(forms.Form): user = forms.CharField(max_length = 100) password = forms.CharField(widget = forms.PasswordInput()) def clean_message(self): username = self.cleaned_data.get("username") dbuser = Dreamreal.objects.filter(name = username) if not dbuser: raise forms.ValidationError("User does not exist in our db!") return username

Ahora, después de llamar al método "is_valid", obtendremos la salida correcta, solo si el usuario está en nuestra base de datos. Si desea verificar un campo de su formulario, simplemente agregue un método que comience por "clean_" y luego el nombre de su campo a su clase de formulario. Levantando formularios. Validación El error es importante.

Django - Carga de archivos

En general, es útil que una aplicación web pueda cargar archivos (foto de perfil, canciones, pdf, palabras .....). Analicemos cómo cargar archivos en este capítulo.

Subiendo una imagen Antes de comenzar a jugar con una imagen, asegúrese de tener instalada la Biblioteca de imágenes de Python (PIL). Ahora, para ilustrar la carga de una imagen, creemos un formulario de perfil, en nuestro myapp / forms.py #-*- coding: utf-8 -*from django import forms class ProfileForm(forms.Form): name = forms.CharField(max_length = 100) picture = forms.ImageFields()

Como puede ver, la diferencia principal aquí son solo los formularios . ImageField . ImageField se asegurará de que el archivo cargado sea una imagen. Si no, la validación del formulario fallará. Ahora creemos un modelo de "Perfil" para guardar nuestro perfil cargado. Esto se hace en myapp / models.py from django.db import models class Profile(models.Model): name = models.CharField(max_length = 50) picture = models.ImageField(upload_to = 'pictures') class Meta: db_table = "profile"

Como puede ver para el modelo, ImageField toma un argumento obligatorio: upload_to . Esto representa el lugar en el disco duro donde se guardarán sus imágenes. Tenga en cuenta que el parámetro se agregará a la opción MEDIA_ROOT definida en su archivo settings.py. Ahora que tenemos el Formulario y el Modelo, creemos la vista, en myapp / views.py #-*- coding: utf-8 -*from myapp.forms import ProfileForm from myapp.models import Profile def SaveProfile(request): saved = False if request.method == "POST": #Get the posted form MyProfileForm = ProfileForm(request.POST, request.FILES) if MyProfileForm.is_valid(): profile = Profile() profile.name = MyProfileForm.cleaned_data["name"]

profile.picture = MyProfileForm.cleaned_data["picture"] profile.save() saved = True else: MyProfileForm = Profileform() return render(request, 'saved.html', locals())

La parte que no debe perderse es que hay un cambio al crear un ProfileForm, agregamos un segundo parámetro: request.FILES . Si no se pasa, la validación del formulario fallará y aparecerá un mensaje que dice que la imagen está vacía. Ahora, solo necesitamos la plantilla saved.html y la plantilla profile.html , para el formulario y la página de redireccionamiento myapp / templates / saved.html

{% if saved %} Your profile was saved. {% endif %} {% if not saved %} Your profile was not saved. {% endif %}

myapp / templates / profile.html

{% csrf_token %}











Login





A continuación, necesitamos nuestro par de URL para comenzar: myapp / urls.py from django.conf.urls import patterns, url from django.views.generic import TemplateView urlpatterns = patterns( 'myapp.views', url(r'^profile/',TemplateView.as_view( template_name = 'profile.html')), url(r'^saved/', 'SaveProfile', name = 'saved') )

Al acceder a "/ myapp / profile", obtendremos la siguiente plantilla profile.html:

Y en la publicación del formulario, la plantilla guardada se representará:

Tenemos una muestra de imagen, pero si desea cargar otro tipo de archivo, no solo imagen, simplemente reemplace el ImageField en Model y Form con FileField .

Django - Configuración de Apache Hasta ahora, en nuestros ejemplos, hemos utilizado el servidor web de desarrollo Django. Pero este servidor es solo para pruebas y no es apto para el entorno de producción. Una vez en producción, necesita un servidor real como Apache, Nginx, etc. Analicemos Apache en este capítulo. El servicio de aplicaciones Django a través de Apache se realiza mediante mod_wsgi. Entonces, lo primero es asegurarse de tener Apache y mod_wsgi

instalados. Recuerde, cuando creamos nuestro proyecto y miramos la estructura del proyecto, parecía que: myproject/ manage.py myproject/ __init__.py settings.py urls.py wsgi.py

El archivo wsgi.py es el que se encarga del enlace entre Django y Apache. Digamos que queremos compartir nuestro proyecto (myproject) con Apache. Solo necesitamos configurar Apache para acceder a nuestra carpeta. Supongamos que ponemos nuestra carpeta myproject en el valor predeterminado "/ var / www / html". En esta etapa, el acceso al proyecto se realizará a través de 127.0.0.1/myproject. Esto dará como resultado que Apache solo enumere la carpeta como se muestra en la siguiente instantánea.

Como se ve, Apache no está manejando cosas de Django. Para que esto se solucione, necesitamos configurar Apache en httpd.conf. Abra el httpd.conf y agregue la siguiente línea: WSGIScriptAlias / /var/www/html/myproject/myproject/wsgi.py WSGIPythonPath /var/www/html/myproject/

Order deny,allow Allow from all

Si puede acceder a la página de inicio de sesión como 127.0.0.1/myapp/connection, verá la siguiente página:

Django - Manejo de cookies A veces, es posible que desee almacenar algunos datos por visitante de sitio según los requisitos de su aplicación web. Siempre tenga en cuenta que las cookies se guardan en el lado del cliente y, según el nivel de seguridad del navegador de su cliente, la configuración de las cookies puede funcionar a veces y otras no. Para ilustrar el manejo de cookies en Django, creemos un sistema usando el sistema de inicio de sesión que creamos antes. El sistema lo mantendrá conectado durante X minutos, y más allá de ese tiempo, estará fuera de la aplicación. Para esto, deberá configurar dos cookies, last_connection y username. Al principio, cambiemos nuestra vista de inicio de sesión para almacenar nuestro nombre de usuario y cookies de última conexión: from django.template import RequestContext def login(request): username = "not logged in" if request.method == "POST": #Get the posted form MyLoginForm = LoginForm(request.POST) if MyLoginForm.is_valid(): username = MyLoginForm.cleaned_data['username'] else: MyLoginForm = LoginForm() response = render_to_response(request, 'loggedin.html', {"username" : username}, context_instance = RequestContext(request))

response.set_cookie('last_connection', datetime.datetime.now()) response.set_cookie('username', datetime.datetime.now()) return response

Como se ve en la vista anterior, la configuración de la cookie se realiza mediante el método set_cookie llamado en la respuesta, no en la solicitud, y también tenga en cuenta que todos los valores de las cookies se devuelven como una cadena. Ahora creemos un formView para el formulario de inicio de sesión, donde no mostraremos el formulario si la cookie está configurada y no tiene más de 10 segundos. def formView(request): if 'username' in request.COOKIES and 'last_connection' in request.COOKIES: username = request.COOKIES['username'] last_connection = request.COOKIES['last_connection'] last_connection_time = datetime.datetime.strptime(last_connection[:-7], "%Y-%m-%d %H:%M:%S") if (datetime.datetime.now() last_connection_time).seconds < 10: return render(request, 'loggedin.html', {"username" : username}) else: return render(request, 'login.html', {}) else: return render(request, 'login.html', {})

Como puede ver en el formulario Vista anterior, el acceso a la cookie que configuró se realiza a través del atributo COOKIES (dict) de la solicitud. Ahora cambiemos el archivo url.py para cambiar la URL para que se empareje con nuestra nueva vista: from django.conf.urls import patterns, url from django.views.generic import TemplateView urlpatterns = patterns('myapp.views', url(r'^connection/','formView', name = 'loginform'), url(r'^login/', 'login', name = 'login'))

Al acceder a / myapp / connection, obtendrá la siguiente página:

Y será redirigido a la siguiente pantalla al enviar:

Ahora, si intenta acceder / myapp / conexión nuevamente en el rango de 10 segundos, será redirigido a la segunda pantalla directamente. Y si accede a / myapp / conexión nuevamente fuera de este rango, obtendrá el formulario de inicio de sesión (pantalla 1).

Django - Sesiones Como se discutió anteriormente, podemos usar cookies del lado del cliente para almacenar una gran cantidad de datos útiles para la aplicación web. Hemos visto antes que podemos usar cookies del lado del cliente para almacenar diversos datos útiles para nuestra aplicación web. Esto lleva a muchos agujeros de seguridad dependiendo de la importancia de los datos que desea guardar. Por razones de seguridad, Django tiene un marco de sesión para el manejo de cookies. Las sesiones se utilizan para abstraer la recepción y el envío de cookies, los datos se guardan en el lado del servidor (como en la base de datos) y la cookie del lado del cliente solo tiene una ID de sesión para su identificación. Las sesiones también son

útiles para evitar casos en los que el navegador del usuario esté configurado para "no aceptar" cookies.

Configurar sesiones En Django, la sesión de habilitación se realiza en la configuración del proyecto.py , agregando algunas líneas a las opciones MIDDLEWARE_CLASSES y INSTALLED_APPS . Esto debe hacerse al crear el proyecto, pero siempre es bueno saberlo, por lo que MIDDLEWARE_CLASSES debería tener: 'django.contrib.sessions.middleware.SessionMiddleware'

Y INSTALLED_APPS debería tener: 'django.contrib.sessions'

De manera predeterminada, Django guarda la información de la sesión en la base de datos (tabla o colección django_session), pero puede configurar el motor para almacenar información utilizando otras formas como: en archivo o en caché . Cuando la sesión está habilitada, cada solicitud (primer argumento de cualquier vista en Django) tiene un atributo de sesión (dict). Creemos una muestra simple para ver cómo crear y guardar sesiones. Hemos creado un sistema de inicio de sesión simple antes (consulte el capítulo de procesamiento de formularios de Django y el capítulo Manejo de cookies de Django). Permítanos guardar el nombre de usuario en una cookie para que, si no se cierra sesión, al acceder a nuestra página de inicio de sesión no vea el formulario de inicio de sesión. Básicamente, hagamos que nuestro sistema de inicio de sesión que utilizamos en el manejo de cookies de Django sea más seguro, guardando las cookies del lado del servidor. Para esto, primero cambiemos nuestra vista de inicio de sesión para guardar nuestro lado del servidor de cookies de nombre de usuario: def login(request): username = 'not logged in' if request.method == 'POST': MyLoginForm = LoginForm(request.POST) if MyLoginForm.is_valid(): username = MyLoginForm.cleaned_data['username'] request.session['username'] = username else: MyLoginForm = LoginForm() return render(request, 'loggedin.html', {"username" : username}

Luego, creemos la vista formView para el formulario de inicio de sesión, donde no mostraremos el formulario si se configura la cookie: def formView(request):

if request.session.has_key('username'): username = request.session['username'] return render(request, 'loggedin.html', {"username" : username}) else: return render(request, 'login.html', {})

Ahora cambiemos el archivo url.py para cambiar la url para que se empareje con nuestra nueva vista: from django.conf.urls import patterns, url from django.views.generic import TemplateView urlpatterns = patterns('myapp.views', url(r'^connection/','formView', name = 'loginform'), url(r'^login/', 'login', name = 'login'))

Al acceder a / myapp / connection, verá la siguiente página:

Y será redirigido a la siguiente página:

Ahora, si intenta acceder / myapp / conexión nuevamente, será redirigido a la segunda pantalla directamente. Creemos una vista de cierre de sesión simple que borre nuestra cookie. def logout(request): try: del request.session['username'] except: pass return HttpResponse("You are logged out.")

Y emparejarlo con una URL de cierre de sesión en myapp / url.py url(r'^logout/', 'logout', name = 'logout'),

Ahora, si accede a / myapp / logout, obtendrá la siguiente página:

Si vuelve a acceder a / myapp / conexión, obtendrá el formulario de inicio de sesión (pantalla 1). Algunas acciones más posibles usando sesiones

Hemos visto cómo almacenar y acceder a una sesión, pero es bueno saber que el atributo de sesión de la solicitud tiene otras acciones útiles como: 

set_expiry ( value ) : establece el tiempo de caducidad de la sesión.



get_expiry_age () - Devuelve el número de segundos hasta que esta sesión expire.



get_expiry_date () : devuelve la fecha en que caducará esta sesión.



clear_expired () : elimina las sesiones caducadas del almacén de sesiones.



get_expire_at_browser_close () - Devuelve Verdadero o Falso, dependiendo de si las cookies de sesión del usuario han expirado cuando se cierra el navegador web del usuario.

Django - Caché

Guardar en caché algo es guardar el resultado de un cálculo costoso, para que no lo realice la próxima vez que lo necesite. El siguiente es un pseudocódigo que explica cómo funciona el almacenamiento en caché: given a URL, try finding that page in the cache if the page is in the cache: return the cached page else: generate the page save the generated page in the cache (for next time) return the generated page

Django viene con su propio sistema de almacenamiento en caché que le permite guardar sus páginas dinámicas, para evitar calcularlas nuevamente cuando sea necesario. Lo bueno del marco de Django Cache es que puede almacenar en caché: 

La salida de una vista específica.



Una parte de una plantilla.



Todo tu sitio.

Para utilizar la memoria caché en Django, lo primero que debe hacer es configurar dónde permanecerá la memoria caché. El marco de la memoria caché ofrece diferentes posibilidades: la memoria caché se puede guardar en la base de datos, en el sistema de archivos o directamente en la memoria. La configuración se realiza en el archivo settings.py de su proyecto.

Configurar caché en la base de datos Simplemente agregue lo siguiente en el archivo settings.py del proyecto: CACHES = { 'default': { 'BACKEND': 'django.core.cache.backends.db.DatabaseCache', 'LOCATION': 'my_table_name', } }

Para que esto funcione y para completar la configuración, necesitamos crear la tabla de caché 'my_table_name'. Para esto, debe hacer lo siguiente: python manage.py createcachetable

Configurar caché en el sistema de archivos Simplemente agregue lo siguiente en el archivo settings.py del proyecto: CACHES = { 'default': { 'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache', 'LOCATION': '/var/tmp/django_cache',

} }

Configurar caché en memoria Esta es la forma más eficiente de almacenamiento en caché, para usarla puede usar una de las siguientes opciones dependiendo de la biblioteca de enlace de Python que elija para la memoria caché: CACHES = { 'default': { 'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache', 'LOCATION': '127.0.0.1:11211', } }

O CACHES = { 'default': { 'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache', 'LOCATION': 'unix:/tmp/memcached.sock', } }

Almacenamiento en caché de todo el sitio La forma más sencilla de usar caché en Django es almacenar en caché todo el sitio. Esto se hace editando la opción MIDDLEWARE_CLASSES en el proyecto settings.py. Lo siguiente debe agregarse a la opción: MIDDLEWARE_CLASSES += ( 'django.middleware.cache.UpdateCacheMiddleware', 'django.middleware.common.CommonMiddleware', 'django.middleware.cache.FetchFromCacheMiddleware', )

Tenga en cuenta que el orden es importante aquí, la actualización debe venir antes de Fetch middleware. Luego, en el mismo archivo, debe configurar: CACHE_MIDDLEWARE_ALIAS – The cache alias to use for storage. CACHE_MIDDLEWARE_SECONDS – The number of seconds each page should be cached.

Almacenamiento en caché de una vista Si no desea almacenar en caché todo el sitio, puede almacenar en caché una vista específica. Esto se hace usando el decorador cache_page que viene con

Django. Digamos que las viewArticles ver -

queremos

almacenar

en

caché

el

resultado

de

from django.views.decorators.cache import cache_page @cache_page(60 * 15) def viewArticles(request, year, month): text = "Displaying articles of : %s/%s"%(year, month) return HttpResponse(text)

Como puede ver, cache_page toma la cantidad de segundos que desea que el resultado de la vista se almacene en caché como parámetro. En nuestro ejemplo anterior, el resultado se almacenará en caché durante 15 minutos. Nota : como hemos visto antes, la vista anterior se asignó a urlpatterns = patterns('myapp.views', url(r'^articles/(?P\d{2})/(?P\d{4})/', 'viewArticles', name = 'articles'),)

Como la URL está tomando parámetros, cada llamada diferente se almacenará en caché por separado. Por ejemplo, la solicitud a / myapp / articles / 02/2007 se almacenará en caché por separado en / myapp / articles / 03/2008. El almacenamiento en caché de una vista también se puede hacer directamente en el archivo url.py. Entonces lo siguiente tiene el mismo resultado que el anterior. Simplemente edite su archivo myapp / url.py y cambie la URL asignada relacionada (arriba) para que sea urlpatterns = patterns('myapp.views', url(r'^articles/(?P\d{2})/(?P\d{4})/', cache_page(60 * 15)('viewArticles'), name = 'articles'),)

Y, por supuesto, ya no es necesario en myapp / views.py.

Almacenamiento en caché de un fragmento de plantilla También puede almacenar en caché partes de una plantilla, esto se hace mediante el uso de la etiqueta de caché . Tomemos nuestra plantilla hello.html : {% extends "main_template.html" %} {% block title %}My Hello Page{% endblock %} {% block content %} Hello World!!!

Today is {{today}}

We are {% if today.day == 1 %} the first day of month. {% elif today.day == 30 %} the last day of month. {% else %}

I don't know. {%endif%}

{% for day in days_of_week %} {{day}}

{% endfor %} {% endblock %}

Y para almacenar en caché el bloque de contenido, nuestra plantilla se convertirá en: {% {% {% {% {%

load cache %} extends "main_template.html" %} block title %}My Hello Page{% endblock %} cache 500 content %} block content %}

Hello World!!!

Today is {{today}}

We are {% if today.day == 1 %} the first day of month. {% elif today.day == 30 %} the last day of month. {% else %} I don't know. {%endif%}

{% for day in days_of_week %} {{day}}

{% endfor %} {% endblock %} {% endcache %}

Como puede ver arriba, la etiqueta de caché tomará 2 parámetros: el tiempo que desea que el bloque se almacene en caché (en segundos) y el nombre que se le dará al fragmento de caché.

Django - Comentarios Antes de comenzar, tenga en cuenta que el marco de comentarios de Django está en desuso, desde la versión 1.5. Ahora puede usar la función externa para hacerlo, pero si aún desea usarla, todavía se incluye en las versiones 1.6 y 1.7. A partir de la versión 1.8 está ausente, pero aún puede obtener el código en una cuenta de GitHub diferente.

El marco de comentarios facilita adjuntar comentarios a cualquier modelo en su aplicación. Para comenzar a usar el marco de comentarios de Django: Edite el archivo settings.py del agregue 'django.contrib.sites' y 'django.contrib.comments' a INSTALLED_APPS:

proyecto la

y opción

INSTALLED_APPS += ('django.contrib.sites', 'django.contrib.comments',)

Obtenga la identificación del sitio: >>> from django.contrib.sites.models import Site >>> Site().save() >>> Site.objects.all()[0].id u'56194498e13823167dd43c64'

Establezca la identificación que obtiene en el archivo settings.py SITE_ID = u'56194498e13823167dd43c64'

Sync db, para crear toda la tabla de comentarios o colección python manage.py syncdb

Agregue las URL de la aplicación de comentarios a urls.py de su proyecto from django.conf.urls import include url(r'^comments/', include('django.contrib.comments.urls')),

Ahora que tenemos instalado el marco, cambiemos nuestras plantillas de saludo para seguir los comentarios sobre nuestro modelo Dreamreal. Enumeraremos, guardaremos los comentarios para una entrada específica de Dreamreal cuyo nombre se pasará como parámetro a la URL / myapp / hello.

Modelo Dreamreal class Dreamreal(models.Model): website = models.CharField(max_length = 50) mail = models.CharField(max_length = 50) name = models.CharField(max_length = 50) phonenumber = models.IntegerField() class Meta: db_table = "dreamreal"

hola vista def hello(request, Name): today = datetime.datetime.now().date() daysOfWeek = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']

dreamreal = Dreamreal.objects.get(name = Name) return render(request, 'hello.html', locals())

plantilla hello.html {% {% {% {%

extends "main_template.html" %} load comments %} block title %}My Hello Page{% endblock %} block content %}

Our Dreamreal Entry:

Name : {{dreamreal.name}}

Website : {{dreamreal.website}}

Phone : {{dreamreal.phonenumber}}

Number of comments : {% get_comment_count for dreamreal as comment_count %} {{ comment_count }}

List of comments :

{% render_comment_list for dreamreal %}

{% render_comment_form for dreamreal %} {% endblock %}

Finalmente, la URL de mapeo a nuestra vista de saludo url(r'^hello/(?P\w+)/', 'hello', name = 'hello'),

Ahora, 

En nuestra plantilla (hello.html), cargue el marco de comentarios con - {% load comments%}



Obtenemos la cantidad de comentarios para que el objeto Dreamreal pase por la vista: {% get_comment_count para dreamreal como comment_count%}



Obtenemos la lista de comentarios para los objetos: {% render_comment_list para dreamreal%}



Mostramos el formulario de comentarios render_comment_form para dreamreal%}

predeterminado:

{%

Al acceder a / myapp / hello / steve obtendrá la información de comentarios para la entrada de Dreamreal cuyo nombre es Steve. Acceder a esa URL te llevará -

Al publicar un comentario, será redirigido a la siguiente página:

Si vuelve a / myapp / hello / steve, verá la siguiente página:

Como puede ver, el número de comentarios es 1 ahora y tiene el comentario debajo de la lista de la línea de comentarios.

Django - RSS Django viene con un marco de generación de alimentación de sindicación. Con él, puede crear fuentes RSS o Atom simplemente subclasificando la clase django.contrib.syndication.views.Feed . Creemos un feed para los últimos comentarios realizados en la aplicación (consulte también Django - capítulo Marco de comentarios). Para esto, creemos un myapp / feeds.py y definamos nuestro feed (puede colocar sus clases de feeds en cualquier lugar de su estructura de código). from django.contrib.syndication.views import Feed from django.contrib.comments import Comment from django.core.urlresolvers import reverse class DreamrealCommentsFeed(Feed): title = "Dreamreal's comments"

link = "/drcomments/" description = "Updates on new comments on Dreamreal entry." def items(self): return Comment.objects.all().order_by("submit_date")[:5] def item_title(self, item): return item.user_name def item_description(self, item): return item.comment def item_link(self, item): return reverse('comment', kwargs = {'object_pk':item.pk}) 

En nuestra clase de de título , enlace y descripción corresponden RSS , y .

a

feed, los atributos los elementos estándar



El método de elementos devuelve los elementos que deben ir en el feed como elemento de elemento. En nuestro caso los últimos cinco comentarios.



El método item_title obtendrá lo que se utilizará como título para nuestro elemento de feed. En nuestro caso el título, será el nombre de usuario.



El método item_description obtendrá lo que irá como descripción para nuestro elemento de feed. En nuestro caso el comentario en sí.



El método item_link creará el enlace al elemento completo. En nuestro caso te llevará al comentario.

Ahora que tenemos nuestro feed, agreguemos una vista de comentario en views.py para mostrar nuestro comentario: from django.contrib.comments import Comment def comment(request, object_pk): mycomment = Comment.objects.get(object_pk = object_pk) text = 'User : %s

'%mycomment.user_name

text += 'Comment : %s

'%mycomment.comment

return HttpResponse(text)

También necesitamos algunas URL en nuestro myapp urls.py para el mapeo: from myapp.feeds import DreamrealCommentsFeed from django.conf.urls import patterns, url urlpatterns += patterns('', url(r'^latest/comments/', DreamrealCommentsFeed()), url(r'^comment/(?P\w+)/', 'comment', name = 'comment'),

)

Al acceder a / myapp / latest / comments / obtendrá nuestro feed:

Luego, haciendo clic en uno de los nombres de usuario lo llevará a: / myapp / comment / comment_id como se define en nuestra vista de comentarios antes y obtendrá -

Por lo tanto, definir un feed RSS es solo una cuestión de subclasificar la clase Feed y asegurarse de que las URL (una para acceder al feed y otra para acceder a los

elementos del feed) estén definidas. Solo como comentario, esto se puede adjuntar a cualquier modelo en su aplicación.

Django - Ajax Básicamente, Ajax es una combinación de tecnologías que se integran entre sí para reducir la cantidad de cargas de página. Generalmente utilizamos Ajax para facilitar la experiencia del usuario final. El uso de Ajax en Django se puede hacer directamente usando una biblioteca Ajax como JQuery u otras. Digamos que quiere usar JQuery, entonces necesita descargar y servir la biblioteca en su servidor a través de Apache u otros. Luego, úselo en su plantilla, tal como lo haría al desarrollar cualquier aplicación basada en Ajax. Otra forma de usar Ajax en Django es usar el marco Django Ajax. El más utilizado es django-dajax, que es una herramienta poderosa para desarrollar de manera fácil y súper rápida la lógica de presentación asíncrona en aplicaciones web, usando Python y casi ningún código fuente JavaScript. Es compatible con cuatro de los marcos de Ajax más populares: Prototype, jQuery, Dojo y MooTools.

Usando Django-dajax Lo primero que debe hacer es instalar django-dajax. Esto se puede hacer usando easy_install o pip $ pip install django_dajax $ easy_install django_dajax

Esto instalará automáticamente django-dajaxice, requerido por django-dajax. Luego necesitamos configurar tanto dajax como dajaxice. Agregue dajax y dajaxice en la configuración de su proyecto.py en la opción INSTALLED_APPS: INSTALLED_APPS += ( 'dajaxice', 'dajax' )

Asegúrese de que en el mismo archivo settings.py, tenga lo siguiente: TEMPLATE_LOADERS = ( 'django.template.loaders.filesystem.Loader', 'django.template.loaders.app_directories.Loader', 'django.template.loaders.eggs.Loader', ) TEMPLATE_CONTEXT_PROCESSORS = ( 'django.contrib.auth.context_processors.auth', 'django.core.context_processors.debug', 'django.core.context_processors.i18n', 'django.core.context_processors.media', 'django.core.context_processors.static', 'django.core.context_processors.request', 'django.contrib.messages.context_processors.messages'

) STATICFILES_FINDERS = ( 'django.contrib.staticfiles.finders.FileSystemFinder', 'django.contrib.staticfiles.finders.AppDirectoriesFinder', 'dajaxice.finders.DajaxiceFinder', ) DAJAXICE_MEDIA_PREFIX = 'dajaxice'

Ahora vaya al archivo myapp / url.py y asegúrese de tener lo siguiente para configurar las URL de dajax y cargar archivos js de dajax statics: from dajaxice.core import dajaxice_autodiscover, dajaxice_config from django.contrib.staticfiles.urls import staticfiles_urlpatterns from django.conf import settings Then dajax urls: urlpatterns += patterns('', url(r'^%s/' % settings.DAJAXICE_MEDIA_PREFIX, include('dajaxice.urls')),) urlpatterns += staticfiles_urlpatterns()

Creemos un formulario simple basado en nuestro modelo Dreamreal para almacenarlo, usando Ajax (significa no actualizar). Al principio, necesitamos nuestra forma Dreamreal en myapp / form.py. class DreamrealForm(forms.Form): website = forms.CharField(max_length = 100) name = forms.CharField(max_length = 100) phonenumber = forms.CharField(max_length = 50) email = forms.CharField(max_length = 100)

Entonces necesitamos un archivo ajax.py en nuestra aplicación: myapp / ajax.py. Ahí es donde está nuestra lógica, ahí es donde ponemos la función que guardará nuestro formulario y luego devuelve la ventana emergente: from from from from

dajaxice.utils import deserialize_form myapp.form import DreamrealForm dajax.core import Dajax myapp.models import Dreamreal

@dajaxice_register def send_form(request, form): dajax = Dajax() form = DreamrealForm(deserialize_form(form)) if form.is_valid(): dajax.remove_css_class('#my_form input', 'error') dr = Dreamreal()

dr.website = form.cleaned_data.get('website') dr.name = form.cleaned_data.get('name') dr.phonenumber = form.cleaned_data.get('phonenumber') dr.save() dajax.alert("Dreamreal Entry %s was successfully saved." % form.cleaned_data.get('name')) else: dajax.remove_css_class('#my_form input', 'error') for error in form.errors: dajax.add_css_class('#id_%s' % error, 'error') return dajax.json()

Ahora creemos la plantilla dreamreal.html, que tiene nuestro formulario:



{{ form.as_p }}

Agregue la vista que acompaña a la plantilla en myapp / views.py def dreamreal(request): form = DreamrealForm() return render(request, 'dreamreal.html', locals())

Agregue la URL correspondiente en myapp / urls.py url(r'^dreamreal/', 'dreamreal', name = 'dreamreal'),

Ahora agreguemos lo necesario en nuestra plantilla para que el Ajax funcione: En la parte superior del archivo, agregue: {% load static %} {% load dajaxice_templatetags %}

Y en la sección de nuestra plantilla dreamreal.html agregue: Estamos utilizando la biblioteca JQuery para este ejemplo, así que agregue:

La función Ajax que se llamará al hacer clic

Tenga en cuenta que necesita el "jquery-1.11.3.min.js" en su directorio de archivos estáticos, y también el jquery.dajax.core.js. Para asegurarse de que todos los archivos estáticos de dajax se sirvan en su directorio estático, ejecute: $python manage.py collectstatic

Nota : a veces puede faltar jquery.dajax.core.js, si eso sucede, simplemente descargue la fuente y tome ese archivo y póngalo en su carpeta estática. Verá la siguiente pantalla al acceder a / myapp / dreamreal / -

Al enviar, obtendrá la siguiente pantalla: