2019

Tutorial de Django en Visual

Studio Code

Lic. Hernán Jasso González

CETI
17/08/2019
Índice

Contenido
Índice ................................................................................................................................................... 2
Tutorial de Django en Visual Studio Code Introducción ..................................................................... 3
Prerrequisitos ...................................................................................................................................... 3
Crear un entorno de proyecto para el tutorial de Django .................................................................. 5
Crea y ejecuta una aplicación Django ............................................................................................... 13
Crea el proyecto Django ................................................................................................................ 13
Crear una aplicación Django.............................................................................................................. 16
Crear un perfil de inicio del depurador ............................................................................................. 17
Usar una plantilla para representar una página ............................................................................... 20
Creación de Django CRUD app (Create, Retrieve, Update, Delete) .................................................. 23
Instalar driver MysqlClient ............................................................................................................ 23
Crear modelo de datos a manejar................................................................................................. 25
Crear vistas para el modelo requerido .......................................................................................... 28
Definir URLS para las páginas creadas .......................................................................................... 31
Templates ...................................................................................................................................... 31
Lista ........................................................................................................................................... 31
Create y Update ........................................................................................................................ 35
Delete ........................................................................................................................................ 37
Detail ......................................................................................................................................... 38
Todo listo! ..................................................................................................................................... 39
Tutorial de Django en Visual Studio Code Introducción

Django es un framework de Python de alto nivel diseñado para un desarrollo web rápido, seguro y
escalable. Django incluye un amplio soporte para enrutamiento de URL, plantillas de páginas y
manejo de datos.

En este tutorial de Django, se creará una aplicación Django simple que nos permitirá realizar las
operaciones CRUD para una tabla de base de datos dada. Crea esta aplicación en el contexto de
Visual Studio Code para comprender cómo trabajar con Django en la terminal, editor y depurador
de VS Code.

Prerrequisitos

Para completar con éxito este tutorial de Django, debe hacer lo siguiente:

Instala la extensión Python.

Instale una versión de Python 3.

Asegúrese de que la ubicación de su intérprete de Python esté incluida en su variable de entorno

PATH. Puede verificar la ubicación ejecutando la ruta en el símbolo del sistema. Si la carpeta del
intérprete de Python no está incluida, abra la Configuración de Windows, busque "entorno",
seleccione Editar variables de entorno para su cuenta, luego edite la variable Ruta para incluir esa
carpeta.
Crear un entorno de proyecto para el tutorial de Django

En esta sección, crearemos un entorno virtual en el que se instala Django. El uso de un entorno
virtual evita la instalación de Django en un entorno global de Python y le brinda un control exacto
sobre las bibliotecas utilizadas en una aplicación.

1. En su sistema de archivos, cree una carpeta de proyecto para este tutorial, como
DjangoTestApp.
 2. En esa carpeta, usaremos el siguiente comando (según corresponda a su computadora)
para crear un entorno virtual llamado env basado en su intérprete actual:

# Windows
python -m venv env

3. Para realizar estos pasos, requerimos ejecutar la aplicación de símbolo de sistema en

modo administrador.
 4. En la pantalla de símbolo del sistema, navegamos hasta la carpeta que acabamos de crear
para realizar este ejercicio, esto lo logramos con el comando "cd", seguido de la carpeta a
la cual queremos acceder. En nuestro caso es el siguiente.

# Windows
cd C:\Hernan\Cursos\CETI\Curso Python CETI\Semana 6\DjangoTestApp

5. Si el comando se ejecuta correctamente, una vez ejecutando el comando anterior, deberá

aparecer nuevamente la línea que indica en qué carpeta nos encontramos dentro del
símbolo del sistema.
6. Para verificar que se haya creado correctamente el ambiente virtual, iremos a la carpeta
creada por medio del explorador de archivos. Deberemos verificar que una carpeta "env"
se ha creado.

7. Abre la carpeta del proyecto en VS Code usando el comando Archivo> Abrir carpeta
8. En VS Code, abriremos la Paleta de comandos (Ver> Paleta de comandos o (Ctrl + Shift +
P)). Luego seleccionamos el comando Python: Seleccionar intérprete:
9. El comando presenta una lista de intérpretes disponibles que VS Code puede localizar
automáticamente. De la lista, seleccione el entorno virtual en su carpeta de proyecto que
comienza con ./env o. \ Env:
10. Ejecutar terminal: cree un nuevo terminal integrado (Ctrl + Shift + `) desde la Paleta de
comandos, que crea un terminal y activa automáticamente el entorno virtual ejecutando
su script de activación.
 11. El entorno seleccionado aparece en el lado izquierdo de la barra de estado del Código VS,
y observe el indicador "(venv)" que le indica que está utilizando un entorno virtual:

12. Instalaremos Django en el entorno virtual ejecutando uno de los siguientes comandos en
el VS Code Terminal:

python -m pip install django

Ahora tienes un entorno autónomo listo para escribir código Django. VS Code activa el entorno
automáticamente cuando usa Terminal: Crear nuevo terminal integrado. Si abres un indicador de
comando o terminal por separado, active el entorno ejecutando source env / bin / generate (Linux
/ macOS) o env \ scripts \ generate (Windows). Usted sabe que el entorno se activa cuando el
símbolo del sistema muestra (env) al principio.

Crea y ejecuta una aplicación Django

En la terminología de Django, un "proyecto Django" se compone de varios archivos de
configuración de nivel de sitio junto con una o más "aplicaciones" que implementa en un servidor
web para crear una aplicación web completa. Un proyecto de Django puede contener múltiples
aplicaciones, cada una de las cuales generalmente tiene una función independiente en el
proyecto, y la misma aplicación puede estar en múltiples proyectos de Django. Una aplicación, por
su parte, es solo un paquete de Python que sigue ciertas convenciones que Django espera.

Para crear una aplicación Django, entonces, es necesario crear primero el proyecto Django para
que sirva como contenedor de la aplicación, luego cree la aplicación en sí. Para ambos propósitos,
utiliza la utilidad administrativa Django, django-admin, que se instala cuando instala el paquete
Django.

Crea el proyecto Django

1. En el VS Code Terminal donde está activado su entorno virtual, ejecutamos el siguiente
comando:

django-admin startproject web_project .

2. Aparecerá la carpeta "web_project" en el explorador de archivos de VS Code

 Este comando startproject supone (mediante el uso de. Al final) que la carpeta actual es su
carpeta de proyecto y crea lo siguiente dentro de ella:

[Link]: la utilidad administrativa de línea de comandos de Django para el proyecto.

Ejecuta comandos administrativos para el proyecto usando python [Link] <comando>
[opciones].

Una subcarpeta llamada web_project, que contiene los siguientes archivos:

 __init__.py: un archivo vacío que le dice a Python que esta carpeta es un paquete
de Python.
 [Link]: un punto de entrada para servidores web compatibles con WSGI para
alojar el proyecto. Por lo general, deja este archivo tal cual, ya que proporciona los
parámetros para los servidores web de producción.
 [Link]: contiene configuraciones para el proyecto Django, que modificaremos
durante el desarrollo de una aplicación web.
 [Link]: contiene una tabla de contenido para el proyecto Django, que también
modifica en el curso del desarrollo.

3. Para verificar el proyecto Django, asegúrate de que su entorno virtual esté activado, luego
inicie el servidor de desarrollo de Django usando el comando

python [Link] runserver

El servidor se ejecuta en el puerto predeterminado 8000, y verás resultados como el

siguiente resultado en la ventana de terminal:
 Cuando ejecuta el servidor por primera vez, crea una base de datos SQLite
predeterminada en el archivo db.sqlite3, que está destinada a fines de desarrollo pero
puede usarse en producción para aplicaciones web de bajo volumen. Además, el servidor
web incorporado de Django está destinado solo para fines de desarrollo local. Sin
embargo, cuando implementa en un servidor web, Django utiliza el servidor web del
servidor. El módulo [Link] en el proyecto Django se encarga de conectarse a los
servidores de producción.

Si deseas utilizar un puerto diferente al predeterminado 8000, especifica el número de

puerto en la línea de comando, como python [Link] runserver 5000.

4. Ctrl + clic en la URL [Link] en la ventana de salida del terminal para abrir
el navegador predeterminado en esa dirección. Si Django está instalado correctamente y
el proyecto es válido, verá la página predeterminada que se muestra a continuación. La
ventana de salida del terminal VS Code también muestra el registro del servidor.
Crear una aplicación Django

1. En el VS Code Terminal con su entorno virtual activado, ejecute el comando startapp de la

utilidad administrativa en la carpeta de su proyecto (donde reside [Link]):

python [Link] startapp principal_app

El comando crea una carpeta llamada principal_app que contiene varios archivos de
código y una subcarpeta. De estos, con frecuencia trabaja con [Link] (que contiene las
funciones que definen páginas en su aplicación web) y [Link] (que contiene clases que
definen sus objetos de datos).

2. Modificaremos principal_app / [Link] para que coincida con el siguiente código, que
crea una vista única para la página de inicio de la aplicación:

from [Link] import render

from [Link] import HttpResponse

def home(request):
return HttpResponse("Hello, Django!")

3. Crea un archivo, principal_app / [Link], con el contenido a continuación. El archivo [Link]

es donde especifica patrones para enrutar diferentes URL a sus vistas apropiadas. El
siguiente código contiene una ruta para asignar la URL raíz de la aplicación ("") a la función
[Link] que acaba de agregar a hello / [Link]:

from [Link] import path

from principal_app import views

urlpatterns = [
path("", [Link], name="home"),
]

4. La carpeta web_project también contiene un archivo [Link], que es donde realmente se

maneja el enrutamiento de URL. Abra web_project / [Link] y modifíquemoslo para que
coincida con el siguiente código (puede retener los comentarios instructivos si lo desea).
Este código extrae principal_app / [Link] de la aplicación usando [Link], que
 mantiene las rutas de la aplicación contenidas dentro de la aplicación. Esta separación es
útil cuando un proyecto contiene múltiples aplicaciones.

from [Link] import admin

from [Link] import include, path

urlpatterns = [
path("", include("principal_app.urls")),
]

5. Guarda todos los archivos modificados con Ctrl + K S.

6. En el VS Code Terminal, nuevamente con el entorno virtual activado, ejecuta el servidor de

desarrollo con python [Link] runserver y abra un navegador en
[Link] para ver una página que muestra "Hello, Django".

Crear un perfil de inicio del depurador

Probablemente ya te estás preguntando si hay una manera más fácil de ejecutar el servidor y
probar la aplicación sin escribir python [Link] runserver cada vez. Afortunadamente, lo hay!
Puede crear un perfil de inicio personalizado en VS Code, que también se utiliza para el inevitable
ejercicio de depuración.

1. Cambie a la vista de depuración en el código VS (usando la barra de actividad del lado

izquierdo). En la parte superior de la vista de depuración, puede ver "Sin configuraciones"
y un punto de advertencia en el ícono de ajustes. Ambos indicadores significan que aún no
tiene un archivo [Link] que contenga configuraciones de depuración:
 2. Seleccione el ícono de ajustes y espere unos segundos a que VS Code cree y abra un
archivo [Link]. (Si está utilizando una versión anterior de VS Code, es posible que se
le solicite una lista de objetivos del depurador, en cuyo caso seleccione Python de la lista).
El archivo [Link] contiene varias configuraciones de depuración, cada una de las
cuales es un objeto JSON separado dentro de la matriz de configuración.

3. Desplacémonos hacia abajo y examine la configuración con el nombre "Python: Django":

{
"name": "Python: Django",
"type": "python",
 "request": "launch",
"program": "${workspaceFolder}/[Link]",
"console": "integratedTerminal",
"args": [
"runserver",
"--noreload"
],
"django": true
},

Esta configuración le dice a VS Code que ejecute "$ {workspaceFolder} /[Link]" utilizando el
intérprete de Python seleccionado y los argumentos en la lista de argumentos. Lanzar el
depurador de VS Code con esta configuración, entonces, es lo mismo que ejecutar python
[Link] runserver --noreload en el VS Code Terminal con su entorno virtual activado. (Si lo
desea, puede agregar un número de puerto como "5000" a los argumentos). La entrada "django":
true también le dice a VS Code que habilite la depuración de las plantillas de página de Django,
que verá más adelante en este tutorial.

4. Guardar [Link] (Ctrl + S). En la lista desplegable de configuración de depuración (que

lee Python: archivo actual) seleccione la configuración Python: Django:
 5. Prueba la configuración seleccionando el comando de menú Depuración> Iniciar
depuración, o seleccionando la flecha verde Iniciar depuración junto a la lista (F5):

Usar una plantilla para representar una página

La aplicación que ha creado hasta ahora en este tutorial genera solo páginas web de texto sin
formato a partir del código Python. Aunque es posible generar HTML directamente en el código,
los desarrolladores evitan esa práctica porque abre la aplicación a los ataques de scripting entre
sitios (XSS). En la función date_view de este tutorial, por ejemplo, uno podría pensar formatear la
salida en código con algo como content = "<h1> ¡Hola," + clean_name + "! </h1>, donde se da el
resultado en el contenido directamente a un navegador. Esta apertura permite que un atacante
coloque HTML malicioso, incluido el código JavaScript, en la URL que termina en clean_name y,
por lo tanto, termina ejecutándose en el navegador.

Una práctica mucho mejor es mantener el HTML fuera de su código por completo mediante el uso
de plantillas, de modo que su código solo se ocupe de los valores de los datos y no de la
representación.

En Django, una plantilla es un archivo HTML que contiene marcadores de posición para los valores
que proporciona el código en tiempo de ejecución. El motor de plantillas de Django se encarga de
hacer las sustituciones al representar la página y proporciona un escape automático para evitar
ataques XSS (es decir, si intentas usar HTML en un valor de datos, verás el HTML representado solo
como texto sin formato). El código, por lo tanto, solo se refiere a los valores de datos y la plantilla
solo se refiere al marcado. Las plantillas de Django proporcionan opciones flexibles, como la
herencia de plantillas, que le permite definir una página base con un marcado común y luego
construir sobre esa base con adiciones específicas de la página.

En esta sección, comenzará creando una sola página utilizando una plantilla. En las secciones
posteriores, configurará la aplicación para que sirva archivos estáticos y luego cree varias páginas
para la aplicación que contengan una barra de navegación desde una plantilla base. Las plantillas
de Django también admiten el flujo de control y la iteración, como puede ver más adelante en este
tutorial en el contexto de la depuración de plantillas.

1. En el archivo web_project / [Link], ubica la lista INSTALLED_APPS y agregue la

siguiente entrada, que asegura que el proyecto conozca la aplicación para que pueda
manejar plantillas:

'principal_app',

2. Dentro de la carpeta principal_app, crea una carpeta llamada templates, y luego otra
subcarpeta llamada principal_app para que coincida con el nombre de la aplicación (esta
estructura de carpetas de dos niveles es la convención típica de Django).

3. En la carpeta templates / principal_app, cree un archivo llamado date_view.html con el

contenido a continuación. Esta plantilla contiene dos marcadores de posición para valores
de datos denominados "nombre" y "fecha", que están delimitados por pares de llaves,
{{y}}. El resto del texto invariable forma parte de la plantilla, junto con el marcado de
 formato (como <strong>). Como puede ver, los marcadores de posición de plantilla
también pueden incluir formato, las expresiones después de la tubería | símbolos, en este
caso utilizando el filtro de fecha y el filtro de hora integrados de Django. El código,
entonces solo necesita pasar el valor de fecha y hora en lugar de una cadena
preformateada:

<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8" />
<title>Hello, Django</title>
</head>
<body>
<strong>Hello there, {{ name }}!</strong> It's {{ date | date:'l,
d F, Y' }} at {{ date | time:'H:i:s' }}
</body>
</html>

4. En la parte superior de [Link], agregue la siguiente declaración de importación:

from [Link] import render

from datetime import datetime

5. También en [Link], agrega la función date_view para usar el método

[Link] para cargar una plantilla y proporcionar el contexto de la plantilla.
El contexto es simplemente el conjunto de variables para usar dentro de la plantilla. La
función de representación toma el objeto de solicitud, seguido de la ruta a la plantilla en
relación con la carpeta de plantillas, luego el objeto de contexto. (Los desarrolladores
generalmente nombran las plantillas de la misma manera que las funciones que las usan,
pero no se requieren nombres coincidentes porque siempre se hace referencia al nombre
de archivo exacto en su código).

def date_view(request, name):

return render(
request,
'principal_app/date_view.html',
{
'name': name,
'date': [Link]()
}
 )

6. En el archivo principal_app/[Link] agregar una ruta en la lista urlpatterns:

path("principal_app/<name>", views.date_view, name="date_view"),

El primer argumento de ruta define una ruta "principal_app /" que acepta una cadena
variable llamada nombre. La cadena se pasa a la función views.date_view especificada en
el segundo argumento de ruta.

Las rutas URL distinguen entre mayúsculas y minúsculas. Por ejemplo, la ruta /
principal_app / <name> es distinta de / Principal_app / <name>. Si desea que la misma
función de vista maneje ambos, defina rutas para cada variante.

Creación de Django CRUD app (Create, Retrieve, Update, Delete)

Una de las tareas más comunes al desarrollar aplicaciones web es escribir, crear, leer, actualizar y
eliminar la funcionalidad (CRUD) para cada tabla que tenga. En esta sección iniciaremos con los
pasos necesarios para trabajar una aplicación básica para cumplir estos propósitos.

Instalar driver MysqlClient

Antes de comenzar con el desarrollo de nuestra aplicación, primero debemos instalar el connector
de Django a la base de datos MySQL. Esto lo logramos ejecutando los siguientes pasos.

1. Ejecutar el comando

pip install mysqlclient

2. En caso de que este comando nos arroje un error, deberemos instalarlo manualmente,
esto lo logramos descargando el paquete de instalación desde la url

[Link]

3. Buscamos el link correspondiente a nuestra versión de python instalada, la cual se puede

ver en la parte inferior izquierda de nuestro VS Code. En mi caso es la 3.7.3 de 32 bits. Para
eso, descargo el link

[Link]

4. Una vez descargado el paquete, en VS Code, ejecutaremos el comando

pip install "Ruta descarga\[Link]"

5. En mi caso es la ruta

pip install "C:\Hernan\Cursos\CETI\Curso Python CETI\mysqlclient-

[Link]"

6. Ejecutamos el comando y nos debería aparecer un resultado similar al mostrado a

continuación:
 7. Ahora, vamos al archivo web_project/[Link] y ubicamos la variable DATABASES para
configurar el conector que acabamos de descargar para MySQL con Django,
reemplazaremos el código existente con el mostrado a continuación. Tomar en cuenta que
las propiedades NAME, USER y PASSWORD, deberán ser acordes con la configuración de
nuestra base de datos.

DATABASES = {
'default': {
'ENGINE': '[Link]',
'NAME': 'inmobiliaria',
'USER': 'root',
'PASSWORD': '123456',
'HOST': '[Link]',
'PORT': '3306',
}
}

8. Una vez realizada esta acción, tenemos listo nuestro conector para comenzar a trabajar.

Crear modelo de datos a manejar

1. Iremos al archivo principal_app/models para codificar nuestro nuevo modelo, el cual es un
espejo de la tabla de base de datos que queramos manipular.

2. Utilizaremos la tabla vendedor, de tal manera que el modelo de datos, debería verse de la
siguiente manera.
from [Link] import models
from [Link] import reverse
from [Link] import MaxValueValidator,
MinValueValidator

# Create your models here.

class Vendedor ([Link]):
id_vendedor = [Link](primary_key=True)
nombre = [Link](max_length=45)

def __str__(self):
return [Link]

def get_absolute_url(self):
return reverse('vendedor_edit', kwargs={'pk': [Link]})

class Meta:
db_table = 'vendedor'

class Operacion ([Link]):

id_operacion = [Link](primary_key=True)
nombre = [Link](max_length=45)

def __str__(self):
return [Link]

def get_absolute_url(self):
return reverse('vendedor_edit', kwargs={'pk': [Link]})

class Meta:
db_table = 'operacion'

class Provincia ([Link]):

id_provincia = [Link](primary_key=True)
nombre = [Link](max_length=45)
 def __str__(self):
return [Link]

def get_absolute_url(self):
return reverse('vendedor_edit', kwargs={'pk': [Link]})

class Meta:
db_table = 'provincia'

class TipoInmueble ([Link]):

id_tipo_inmueble = [Link](primary_key=True)
nombre = [Link](max_length=45)

def __str__(self):
return [Link]

def get_absolute_url(self):
return reverse('vendedor_edit', kwargs={'pk': [Link]})

class Meta:
db_table = 'tipo_inmueble'

class Inmueble ([Link]):

id_inmueble = [Link](primary_key=True)
fecha_alta = [Link](auto_now_add=True)
id_tipo = [Link](TipoInmueble, db_column='id_tipo',
on_delete=[Link])
id_operacion = [Link](Operacion,
db_column='id_operacion', on_delete=[Link])
id_provincia = [Link](Provincia,
db_column='id_provincia', on_delete=[Link])
superficie =
[Link](validators=[MinValueValidator(0.00),
MaxValueValidator(9999.99)])
precio_venta =
[Link](validators=[MinValueValidator(0.00),
MaxValueValidator(99999999.99)])
fecha_venta = [Link](null=True, blank=True)
 id_vendedor = [Link](Vendedor,
db_column='id_vendedor', on_delete=[Link])

def __str__(self):
return str(self.id_inmueble)

def get_absolute_url(self):
return reverse('vendedor_edit', kwargs={'pk': [Link]})

class Meta:
db_table = 'inmueble'

Crear vistas para el modelo requerido

1. En este ejercicio utilizaremos las vistas basadas en clases deDjango para crear nuestras
páginas, el archivo principal_app/[Link] debería verse de la siguiente manera.

from [Link] import render

from [Link] import HttpResponse
from [Link] import ListView, DetailView
from [Link] import CreateView, UpdateView,
DeleteView
from [Link] import reverse_lazy
from datetime import datetime
import re

from principal_app.models import Vendedor

from principal_app.models import Inmueble

def home(request):
return HttpResponse("Hello, Django!" )

def date_view(request, name):

return render(
request,
'principal_app/date_view.html',
{
'name': name,
'date': [Link]()
}
)

class VendedorList(ListView):
model = Vendedor

class VendedorView(DetailView):
model = Vendedor

class VendedorCreate(CreateView):
model = Vendedor
fields = ['id_vendedor', 'nombre']
success_url = reverse_lazy('vendedor_list')

class VendedorUpdate(UpdateView):
model = Vendedor
fields = ['id_vendedor', 'nombre']
 success_url = reverse_lazy('vendedor_list')

class VendedorDelete(DeleteView):
model = Vendedor
success_url = reverse_lazy('vendedor_list')

class InmuebleList(ListView):
model = Inmueble

class InmuebleView(DetailView):
model = Inmueble

class InmuebleCreate(CreateView):
model = Inmueble
fields = ['id_inmueble', 'id_tipo',
'id_operacion', 'id_provincia', 'superficie',
'precio_venta']
readonly_fields = ['fecha_alta']
success_url = reverse_lazy('inmueble_list')

class InmuebleUpdate(UpdateView):
model = Inmueble
fields = ['id_inmueble', 'id_tipo',
'id_operacion', 'id_provincia', 'superficie',
'precio_venta', 'fecha_venta', 'id_vendedor']
readonly_fields = ['fecha_alta']
success_url = reverse_lazy('inmueble_list')

class InmuebleDelete(DeleteView):
model = Inmueble
success_url = reverse_lazy('inmueble_list')
Definir URLS para las páginas creadas
1. Necesitamos definir las URLs de nuestra app en el archivo principal_app/[Link]. El archivo
debería de quedar de la siguiente manera.

from [Link] import path

from principal_app import views

urlpatterns = [
path("", [Link], name="home"),
path('list', [Link].as_view(),
name='vendedor_list'),
path('view/<int:pk>', [Link].as_view(),
name='vendedor_list'),
path('new', [Link].as_view(),
name='vendedor_create'),
path('view/<int:pk>', [Link].as_view(),
name='vendedor_view'),
path('edit/<int:pk>', [Link].as_view(),
name='vendedor_update'),
path('delete/<int:pk>', [Link].as_view(),
name='vendedor_delete'),
path('inmueble/list', [Link].as_view(),
name='inmueble_list'),
path('inmueble/view/<int:pk>', [Link].as_view(),
name='inmueble_list'),
path('inmueble/new', [Link].as_view(),
name='inmueble_create'),
path('inmueble/edit/<int:pk>', [Link].as_view(),
name='inmueble_update'),
path('inmueble/delete/<int:pk>',
[Link].as_view(), name='inmueble_delete'),
]

Templates
Lista
principal_app/templates/principal_app/vendedor_list.html será usado para la vista en forma de
lista.
<link rel="stylesheet"
href="//[Link]/bootstrap/3.2.0/css/[Link]">
<link rel="stylesheet"
href="//[Link]/bootstrap/3.2.0/css/bootstrap-
[Link]">
<h1>Vendedores</h1>

<table class="table table-hover">

<thead>
<tr>
<th scope="col">ID</th>
<th scope="col">Nombre</th>
<th scope="col">View</th>
<th scope="col">Edit</th>
<th scope="col">Delete</th>
</tr>
</thead>
<tbody>

{% for vendedor in object_list %}

<tr>
<td>{{ vendedor.id_vendedor }}</td>
<td>{{ [Link] }}</td>
<td>
<a href="{% url "vendedor_list" vendedor.id_vendedor %}"
class="btn btn-info " >
<span class="glyphicon glyphicon-edit"></span> Ver detalle
</a>
</td>
<td>
<a href="{% url "vendedor_update" vendedor.id_vendedor %}"
class="btn btn-primary">
<span class="glyphicon glyphicon-pencil"></span> Editar
</a>
</td>
<td>
<a href="{% url "vendedor_delete" vendedor.id_vendedor %}"
class="btn btn-danger">
 <span class="glyphicon glyphicon-trash"></span> Eliminar
</a>
</td>
</tr>
{% endfor %}
</tbody>
</table>

<a href="{% url "vendedor_create" %}" class="btn btn-success"> <span

class="glyphicon glyphicon-plus"></span>New</a>

principal_app/templates/principal_app/inmueble_list.html será usado para la vista en forma de

lista.

<link rel="stylesheet"
href="//[Link]/bootstrap/3.2.0/css/[Link]">
<link rel="stylesheet"
href="//[Link]/bootstrap/3.2.0/css/bootstrap-
[Link]">
<h1>Inmuebles</h1>

<a href="{% url "inmueble_create" %}" class="btn btn-success"> <span

class="glyphicon glyphicon-plus"></span>New</a>
<table class="table table-hover">
<thead>
<tr>
<th scope="col">ID</th>
<th scope="col">Fecha Alta</th>
<th scope="col">Tipo</th>
<th scope="col">Operación</th>
<th scope="col">Provincia</th>
<th scope="col">Superficie</th>
<th scope="col">Precio Venta</th>
<th scope="col">Fecha Venta</th>
<th scope="col">Vendedor</th>
<th scope="col">View</th>
<th scope="col">Edit</th>
<th scope="col">Delete</th>
</tr>
</thead>
<tbody>

{% for inmueble in object_list %}

<tr>
<td>{{ inmueble.id_inmueble }}</td>
<td>{{ inmueble.fecha_alta | date:"d/m/Y" }}</td>
<td>{{ inmueble.id_tipo }}</td>
<td>{{ inmueble.id_operacion }}</td>
<td>{{ inmueble.id_provincia }}</td>
<td>{{ [Link] }}</td>
<td>{{ inmueble.precio_venta }}</td>
<td>{{ inmueble.fecha_venta | date:"d/m/Y" }}</td>
<td>{{ inmueble.id_vendedor }}</td>
<td>
<a href="{% url "inmueble_list" inmueble.id_inmueble %}"
class="btn btn-info " >
<span class="glyphicon glyphicon-edit"></span> Ver detalle
</a>
</td>
 <td>
<a href="{% url "inmueble_update" inmueble.id_inmueble %}"
class="btn btn-primary">
<span class="glyphicon glyphicon-pencil"></span> Editar
</a>
</td>
<td>
<a href="{% url "inmueble_delete" inmueble.id_inmueble %}"
class="btn btn-danger">
<span class="glyphicon glyphicon-trash"></span> Eliminar
</a>
</td>
</tr>
{% endfor %}
</tbody>
</table>

Create y Update
principal_app/templates/principal_app/vendedor_form.html será usado para la vista de creación
y actualización.
<link rel="stylesheet"
href="//[Link]/bootstrap/3.2.0/css/[Link]">
<link rel="stylesheet"
href="//[Link]/bootstrap/3.2.0/css/bootstrap-
[Link]">

<h1>Vendedor</h1>
<form method="post">{% csrf_token %}
{{ form.as_p }}
<input type="submit" class="btn btn-primary" value="Submit" />
</form>

principal_app/templates/principal_app/inmueble_form.html será usado para la vista de creación y

actualización.

<link rel="stylesheet"
href="//[Link]/bootstrap/3.2.0/css/[Link]">
<link rel="stylesheet"
href="//[Link]/bootstrap/3.2.0/css/bootstrap-
[Link]">

<h1>Inmueble</h1>
<form method="post">{% csrf_token %}
{{ form.as_p }}
<input type="submit" class="btn btn-primary" value="Submit" />
</form>
Delete
principal_app/templates/principal_app/vendedor_confirm_delete.html será usado para la vista de
creación y actualización.

<link rel="stylesheet"
href="//[Link]/bootstrap/3.2.0/css/[Link]">
<link rel="stylesheet"
href="//[Link]/bootstrap/3.2.0/css/bootstrap-
[Link]">

<h1>Vendedor Delete</h1>
<form method="post">{% csrf_token %}
Seguro que deseas eliminar al vendedor: "{{ object }}" ?
<input type="submit" class="btn btn-danger" value="Eliminar" />
</form>

principal_app/templates/principal_app/inmueble_confirm_delete.html será usado para la vista de

creación y actualización.

<link rel="stylesheet"
href="//[Link]/bootstrap/3.2.0/css/[Link]">
<link rel="stylesheet"
href="//[Link]/bootstrap/3.2.0/css/bootstrap-
[Link]">

<h1>Eliminar Vendedor</h1>
<form method="post">{% csrf_token %}
Seguro que deseas eliminar al vendedor: "{{ object }}" ?
<input type="submit" class="btn btn-danger" value="Eliminar" />
</form>

Detail
principal_app/templates/principal_app/vendedor_detail.html será usado para la vista de detalle.

<link rel="stylesheet"
href="//[Link]/bootstrap/3.2.0/css/[Link]">
<link rel="stylesheet"
href="//[Link]/bootstrap/3.2.0/css/bootstrap-
[Link]">

<h1>Vendedor Details</h1>
<h2>ID: {{object.id_vendedor}}</h2>
Nombre: {{ [Link] }}

principal_app/templates/principal_app/inmueble_detail.html será usado para la vista de detalle.

<link rel="stylesheet"
href="//[Link]/bootstrap/3.2.0/css/[Link]">
<link rel="stylesheet"
href="//[Link]/bootstrap/3.2.0/css/bootstrap-
[Link]">

<h1>Detalle Inmueble </h1>

<h2>ID: {{object.id_inmueble}}</h2>
<h3>Fecha Alta: {{ object.fecha_alta | date:"d/m/Y" }}</h3>
<h3>Tipo Inmueble:{{ object.id_tipo }}</h3>
<h3>Operación: {{ object.id_operacion }}</h3>
<h3>Provincia: {{ object.id_provincia }}</h3>
<h3>Superficie: {{ [Link] }}</h3>
<h3>Precio Venta: {{ object.precio_venta }}</h3>
<h3>Fecha Venta: {{ object.fecha_venta | date:"d/m/Y" }}</h3>
<h3>Vendedor: {{ object.id_vendedor }}</h3>

Todo listo!
Iniciemos nuestro servidor de aplicaciones y veamos cómo trabaja nuestra nueva página web.