Translation of the Tutorial And Videos section to Spanish (#3718)

* Add basic files structure for spanish translation of the doc

* Translate the video tutorial index page

* Translate Before Start page

* Translate What is an app page

* Translate the Bench page

* Translate Conslusion page of the tutorial

* Translate to spanish Tutorial Index page

* Translate to spanish Reports page

* Translate to Spanish Roles Page

* Translate to Spanish the Tutorial Model Page

* Translate to Spanish the tutorial Single Doctypes page

* Translate to Spanish the tutorial Doctype files structure page

* Translate to Spanish the tutorial Start Bench page

* Translate to Spanish the tutorial New App page

* Translate to Spanish the tutorial Client Side Script page

* Translate to Spanish the tutorial Users and records page

* Translate to Spanish the tutorial Setting Up the site page

* Translate to Spanish the tutorial Task Runner page

* Translate to Spanish the tutorial Controllers Page

* Translate to Spanish the tutorial Doctypes page

* Translate to Spanish the tutorial Naming And Linking page

* Translate to Spanish the tutorial Web Views page

frappe/docs/user/es/index.md

+# Desarrollo de aplicaciones con Frappe
+
+{index}

frappe/docs/user/es/index.txt

+tutorial
+bench
+guides
+videos

frappe/docs/user/es/tutorial/app.md

+# Qué es una aplicación
+
+Una aplicación en Frappe es una aplicación estandar en Python. Puedes estructurar una aplicación hecha en Frappe de la misma forma que estructuras una aplicación en Python.
+Para implementación, Frappe usa los  Python Setuptools, lo que nos permite facilmente instalar la aplicación en cualquier computadora.
+
+El Framework Frappe provee una interfaz WSGI y para el desarrollo puedes usar el servidor interno de frappe llamado Werkzeug. Para implementación en producción, recomendamos usar nginx y gunicorn.
+
+Frappe tambien soporta la architectura multi-tenant. Esto significa que puedes correr varios "sitios" en su instalación, cada uno de ellos estará poniendo a disposición un conjunto de aplicaciones y usuarios. La base de datos para cada sitio es separada.
+
+{next}

frappe/docs/user/es/tutorial/before.md

+# Antes de empezar
+
+<p class="lead">Una lista de recursos que te ayudaran a inicar con el desarrollo de aplicaciones usando Frappe.</p>
+
+---
+
+#### 1. Python
+
+Frappe usa Python (v2.7) como lenguaje de parte del servidor. Es altamente recomendable aprender Python antes de iniciar a crear aplicaciones con Frappe.
+
+Para escribir código de calidad del lado del servidor, también debes incluir pruebas automatizadas.
+
+Recursos:
+ 1. [Tutorial sobre Python de Codecademy](https://www.codecademy.com/learn/python)
+ 1. [Tutorial Oficial de Python](https://docs.python.org/2.7/tutorial/index.html)
+ 1. [Tutorial básico de Test-driven development](http://code.tutsplus.com/tutorials/beginning-test-driven-development-in-python--net-30137)
+
+---
+
+#### 2. MariaDB / MySQL
+
+Para crear aplicaciones con frappe, debes entender los conceptops básicos del manejo de base de datos, como instalarlas, acceder, crear nueva base de datos, y hacer consultas básicas con SQL.
+
+Recursos:
+ 1. [Tutorial sobre SQL de Codecademy](https://www.codecademy.com/learn/learn-sql)
+ 1. [Tutorial Básico de MySQL de DigitalOcean](https://www.digitalocean.com/community/tutorials/a-basic-mysql-tutorial)
+ 1. [Introducción a MariaDB](https://mariadb.com/kb/en/mariadb/documentation/getting-started/)
+
+---
+
+#### 3. HTML / CSS
+
+Si quieres construir interfaces de usuario usando Frappe, necesitas aprender los conceptops básicos de HTML / CSS y el framework de CSS Bootstrap.
+
+Recursos:
+ 1. [Tutorial sobre HTML/CSS de Codecademy](https://www.codecademy.com/learn/learn-html-css)
+ 1. [Introducción a Bootstrap](https://getbootstrap.com/getting-started/)
+
+---
+
+#### 4. JavaScript and jQuery
+
+Para modificar formularios y crear interfaces de usuarios interactivas, deberías aprender JavaScript y la librería JQuery.
+
+
+Recursos:
+ 1. [Tutorial sobre JavaScript de Codecademy](https://www.codecademy.com/learn/learn-javascript)
+ 1. [Tutorial sobre jQuery de Codecademy](https://www.codecademy.com/learn/jquery)
+---
+
+#### 5. Manejar de plantillas Jinja
+
+Si estas modificando plantillas de Impresión o Páginas Web, tienes que aprender a utilizar el manejar de plantillas Jinja. Es una forma facíl de crear páginas web dinámicas.
+
+Recursos:
+ 1. [Primer on Jinja Templating](https://realpython.com/blog/python/primer-on-jinja-templating/)
+ 1. [Documentación oficial](http://jinja.pocoo.org/)
+
+---
+
+#### 6. Git and GitHub
+
+Aprende como contribuir en un proyecto de código abierto usando Git y GitHub, dos increíbles herramientes que te ayudan a gestionar tu código y compartirlo con otros.
+
+Recursos:
+ 1. [Tutorial Básico de Git](https://try.github.io)
+ 2. [Cómo contribuir al Código Abierto](https://opensource.guide/how-to-contribute/)
+
+---
+
+Cuando estes listo, puedes intentar [crear una aplicación simple]({{ docs_base_url }}/user/es/tutorial/app) usando Frappe.

frappe/docs/user/es/tutorial/bench.md

+# Instalando el Frappe Bench
+
+La forma más facíl de configurar frappe en un computador usando sitemas basados en Unix es usando frappe-bench. Lee las instrucciones detalladas acerca de como instalarlo usando Frappe Bench.
+
+> [https://github.com/frappe/bench](https://github.com/frappe/bench)
+
+Con Frappe Bench vas a poder configurar y hostear multiples aplicaciones y sitios, también va a configurar un entorno virtual de Python por lo que vas a tener un entorno apartado para correr sus aplicaciones (y no va a tener conflictos de versiones con otros entornos de desarrollo).
+
+El comando `bench` va a ser instalado en su sistema para ayudarlo en la fase de desarrollo y el manejo de la aplicación.
+
+{next}

frappe/docs/user/es/tutorial/conclusion.md

+# Conclusión
+
+Esperamos que esto te haya dado una idea de como son desarrolladas las aplicaicones en Frappe. El objetivo era de que de manera breve se tocaran varios de los aspectos del desarrollo de aplicaciones. Para obtener ayuda en inconvenientes o temas específicos, favor revisar el API.
+
+Para ayuda, únete a la comunidad en el [canal de chat en Gitter](https://gitter.im/frappe/erpnext) o el [foro de desarrollo](https://discuss.erpnext.com)

frappe/docs/user/es/tutorial/controllers.md

+# Controladores (Controllers)
+
+El siguiente paso va a ser agregar métodos y eventos a los modelos. En la aplicación, debemos asegurar que si una Library Transaction es creada, el Article que se solicita debe estar en disponibilidad y el miembro que lo solicita debe tener una membresía (membership) válida.
+
+Para esto, podemos escribir una validación que se verifique justo en el momento que una Library Transaction es guardada. Para lograrlo, abre el archivo `library_management/doctype/library_transaction/library_transaction.py`.
+
+Este archivo es el controlador para el objeto Library Transaction. En este archivo puedes escribir métodos para:
+
+1. `before_insert`
+1. `validate` (Antes de insertar o actualizar)
+1. `on_update` (Despues de guardar)
+1. `on_submit` (Cuando el documento es presentado como sometido o presentado)
+1. `on_cancel`
+1. `on_trash` (antes de ser eliminado)
+
+Puedes escribir métodos para estos eventos y estos van a ser llamados por el framework automóticamente cuando el documento pase por uno de esos estados.
+
+Aquí les dejo el controlador completo:
+
+	from __future__ import unicode_literals
+	import frappe
+	from frappe import _
+	from frappe.model.document import Document
+
+	class LibraryTransaction(Document):
+		def validate(self):
+			last_transaction = frappe.get_list("Library Transaction",
+				fields=["transaction_type", "transaction_date"],
+				filters = {
+					"article": self.article,
+					"transaction_date": ("<=", self.transaction_date),
+					"name": ("!=", self.name)
+				})
+			if self.transaction_type=="Issue":
+				msg = _("Article {0} {1} no ha sido marcado como retornado desde {2}")
+				if last_transaction and last_transaction[0].transaction_type=="Issue":
+					frappe.throw(msg.format(self.article, self.article_name,
+						last_transaction[0].transaction_date))
+			else:
+				if not last_transaction or last_transaction[0].transaction_type!="Issue":
+					frappe.throw(_("No puedes retornar un Article que no ha sido prestado."))
+
+En este script:
+
+1. Obtenemos la última transacción antes de la fecha de la transacción actual usando la funcion `frappe.get_list`
+1. Si la última transacción es algo que no nos gusta, lanzamos una excepción usando `frappe.throw`
+1. Usamos el método `_("texto")` para identificar las cadenas que pueden ser traducidas.
+
+Verifica si sus validaciones funcionan creando nuevos registros.
+
+<img class="screenshot" alt="Transaction" src="{{docs_base_url}}/assets/img/lib_trans.png">
+
+#### Depurando
+
+Para depurar, siempre mantener abierta su consola JS. Verifíca rastros de Javascript y del Servidor.
+
+Siempre verifica su terminal para las excepciones. Cualquier **500 Internal Server Errors** va a ser mostrado en la terminal en la que está corriendo el servidor.
+
+{next}

frappe/docs/user/es/tutorial/doctype-directory-structure.md

+# Estructura de directorios de un DocType
+
+Despues de guardar los DocTypes, revisa que los archivos `.json` y `.py` fuueron creados en módulo `apps/library_management/library_management`. La estructura de directorios despues de crear los modelos debería ser similar a la siguiente:
+
+	.
+	├── MANIFEST.in
+	├── README.md
+	├── library_management
+	..
+	│   ├── library_management
+	│   │   ├── __init__.py
+	│   │   └── doctype
+	│   │       ├── __init__.py
+	│   │       ├── article
+	│   │       │   ├── __init__.py
+	│   │       │   ├── article.json
+	│   │       │   └── article.py
+	│   │       ├── library_member
+	│   │       │   ├── __init__.py
+	│   │       │   ├── library_member.json
+	│   │       │   └── library_member.py
+	│   │       ├── library_membership
+	│   │       │   ├── __init__.py
+	│   │       │   ├── library_membership.json
+	│   │       │   └── library_membership.py
+	│   │       └── library_transaction
+	│   │           ├── __init__.py
+	│   │           ├── library_transaction.json
+	│   │           └── library_transaction.py
+
+{next}

frappe/docs/user/es/tutorial/doctypes.md

+# DocType
+
+Despues de crear los Roles, vamos a crear los **DocTypes**
+
+Para crear un nuevo **DocType**, ir a:
+
+> Developer > Documents > Doctype > New
+
+<img class="screenshot" alt="New Doctype" src="{{docs_base_url}}/assets/img/doctype_new.png">
+
+En el DocType, primero el módulo, lo que en nuestro caso es **Library Management**
+
+#### Agregando Campos
+
+En la tabla de campos, puedes agregar los campos (propiedades) de el DocType (Article).
+
+Los campos son mucho más que solo columnas en la base de datos, pueden ser:
+Fields are much more than database columns, they can be:
+
+1. Columnas en la base de datos
+1. Ayudantes de diseño (definidores de secciones / columnas)
+1. Tablas hijas (Tipo de dato Table)
+1. HTML
+1. Acciones (botones)
+1. Adjuntos o Imagenes
+
+Vamos a agregar los campos de el Article.
+
+<img class="screenshot" alt="Adding Fields" src="{{docs_base_url}}/assets/img/doctype_adding_field.png">
+
+Cuando agredas los campos, necesitas llenar el campo **Type**. **Label** es opcional para los Section Break y Column Break. **Name** (`fieldname`) es el nombre de la columna en la tabla de la base de datos y tambien el nombre de la propiedad para el controlador. Esto tiene que ser *code friendly*, i.e. Necesitas poner _ en lugar de " ". Si dejas en blanco este campo, se va a llenar automáticamente al momento de guardar.
+
+Puedes establecer otras propiedades al campo como si es obligatorio o no, si es de solo lectura, etc.
+
+Podemos agregar los siguientes campos:
+
+1. Article Name (Data)
+2. Author (Data)
+3. Description
+4. ISBN
+5. Status (Select): Para los campos de tipo Select, vas a escribir las opciones. Escribe **Issued** y **Available** cada una en una linea diferente en la caja de texto de Options. Ver el diagrama más abajo.
+6. Publisher (Data)
+7. Language (Data)
+8. Image (Adjuntar Imagen)
+
+
+#### Agregar permisos
+
+Despues de agregar los campos, dar click en hecho y agrega una nueva fila en la sección de Permission Roles. Por ahora, vamos a darle accesos Lectura, Escritura, Creación y Reportes al Role **Librarian**. Frappe cuenta con un sistema basados en el modelo de Roles finamente granulado. Puedes cambiar los permisos más adealante usando el **Role Permissions Manager** desde **Setup**.
+
+<img class="screenshot" alt="Adding Permissions" src="{{docs_base_url}}/assets/img/doctype_adding_permission.png">
+
+#### Guardando
+
+Dar click en el botón de **Guardar**. Cuando el botón es clickeado, una ventana emergente le va a preguntar por el nombre. Vamos a darle el nombre de **Article** y guarda el DocType.
+
+Ahora accede a mysql y verifica que en la base de datos que se ha creado una nueva tabla llamada tabArticle.
+
+	$ bench mysql
+	Welcome to the MariaDB monitor.  Commands end with ; or \g.
+	Your MariaDB connection id is 3931
+	Server version: 5.5.36-MariaDB-log Homebrew
+
+	Copyright (c) 2000, 2014, Oracle, Monty Program Ab and others.
+
+	Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.
+
+	MariaDB [library]> DESC tabArticle;
+	+--------------+--------------+------+-----+---------+-------+
+	| Field        | Type         | Null | Key | Default | Extra |
+	+--------------+--------------+------+-----+---------+-------+
+	| name         | varchar(255) | NO   | PRI | NULL    |       |
+	| creation     | datetime(6)  | YES  |     | NULL    |       |
+	| modified     | datetime(6)  | YES  |     | NULL    |       |
+	| modified_by  | varchar(40)  | YES  |     | NULL    |       |
+	| owner        | varchar(60)  | YES  |     | NULL    |       |
+	| docstatus    | int(1)       | YES  |     | 0       |       |
+	| parent       | varchar(255) | YES  | MUL | NULL    |       |
+	| parentfield  | varchar(255) | YES  |     | NULL    |       |
+	| parenttype   | varchar(255) | YES  |     | NULL    |       |
+	| idx          | int(8)       | YES  |     | NULL    |       |
+	| article_name | varchar(255) | YES  |     | NULL    |       |
+	| status       | varchar(255) | YES  |     | NULL    |       |
+	| description  | text         | YES  |     | NULL    |       |
+	| image        | varchar(255) | YES  |     | NULL    |       |
+	| publisher    | varchar(255) | YES  |     | NULL    |       |
+	| isbn         | varchar(255) | YES  |     | NULL    |       |
+	| language     | varchar(255) | YES  |     | NULL    |       |
+	| author       | varchar(255) | YES  |     | NULL    |       |
+	+--------------+--------------+------+-----+---------+-------+
+	18 rows in set (0.00 sec)
+
+Como puedes ver, junto con los DocFields, algunas columnas fueron agregadas a la tabla. Las importantes a notar son, la clave primaria, `name`, `owner`(El usuario que creo el registro),
+`creation` y `modified` (timestamps para la creación y última modificación).
+
+{next}

frappe/docs/user/es/tutorial/form-client-scripting.md

+## Añadir Scripts a nuestros formularios
+
+Ya que tenemos creado el sistema básico que funciona sin problemas sin escribir una linea de código. Vamos a escribir algunos scripts
+para hablar la aplicación más interactiva y agregar validaciones para que el usuario no pueda introducir información erronea.
+
+### Scripts del lado del Cliente
+
+En el DocType **Library Transaction**, solo tenemos campo para el Nombre del miembro. No hemos creado dos campos. Esto podría ser dos campos (y probablemente debería), pero para los motivos del ejemplo, vamos a considerar que tenemos que implementarlo así. Para hacerlo vamos a tener que escribir un manejador de eventos para el evento que ocurre cuando el usuario selecciona el campo `library_member` y luego accede a la información del miembro desde el servidor usando el REST API y cambia los valores en el formulario.
+
+Para empezar el script, en el directorio `library_management/doctype/library_transaction`, crea un nuevo archivo `library_transaction.js`.
+Este archivo va a ser ejecutado automáticamente cuando la primer  Library Transaction es abierta por el usuario. En este archivo, podemos establecer eventos y escribir otras funciones.
+
+#### library_transaction.js
+
+	frappe.ui.form.on("Library Transaction", "library_member",
+		function(frm) {
+			frappe.call({
+				"method": "frappe.client.get",
+				args: {
+					doctype: "Library Member",
+					name: frm.doc.library_member
+				},
+				callback: function (data) {
+					frappe.model.set_value(frm.doctype,
+						frm.docname, "member_name",
+						data.message.first_name
+						+ (data.message.last_name ?
+							(" " + data.message.last_name) : ""))
+				}
+			})
+		});
+
+1. **frappe.ui.form.on(*doctype*, *fieldname*, *handler*)** es usada para establecer un manejador de eventos cuando la propiedad library_member es seleccionada.
+1. En el manejador, vamos a disparar una llamada AJAX a `frappe.client.get`. En respuesta obtenemos el objeto consultado en formato JSON. [Aprende más acerca del API](/frappe/user/en/guides/integration/rest_api).
+1. Usando **frappe.model.set_value(*doctype*, *name*, *fieldname*, *value*)** cambiamos el valor en el formulario.
+
+**Nota:**  Para verificar si su script funciona, recuerda Recargar/Reload la página antes de probar el script. Los cambios realizados a los script del lado del Cliente no son automáticamente cargados nuevamente cuando estas en modo desarrollador.
+
+{next}

frappe/docs/user/es/tutorial/index.md

+# Tutorial sobre Frappe
+
+En esta guía, vamos a mostrarte como crear una aplicación desde cero usando **Frappe**. Usando el ejemplo de un Sistema de Gestión de Librería. Vamos a cubrir:
+
+1. Instalación
+1. Creando una nueva App
+1. Creando Modelos
+1. Creando Usuarios y Registros
+1. Creando Controladores
+1. Creando Vistas Web
+1. Configurando Hooks y Tareas
+
+## Para Quién es este tutorial?
+
+Esta guía esta orientada para desarrolladores de software que estan familiarizados con el proceso de como son creadas y servidas las aplicaciones web. El Framework Frappe está escrito en Python y usa MariaDB como base de datos y para la creación de las vistas web usa HTML/CSS/Javascript. Por lo que sería excelente si estas familiarizado con estas tecnologías.
+Por lo menos, si nunca haz usado Python antes, deberías tomar un tutorial rápido antes de iniciar con este tutorial.
+
+Frappe usa el sistema de gestión de versiones en GitHub. También, es importante estar familiarizado con los conceptos básicos de git y tener una cuenta en GitHub para manejar sus aplicaciones.
+
+## Ejemplo
+
+Para esta guía, vamos a crear una aplicación simple llamada **Library Management**. En esta aplicación vamos a tener los siguientes modelos (Permanecerán en inglés para que coincidan con las imagenes):
+
+1. Article (Libro o cualquier otro artículo que pueda ser prestado)
+1. Library Member
+1. Library Transaction (Entrega o Retorno de un artículo)
+1. Library Membership (Un período en el que un miembro esta permitido hacer una trasacción)
+1. Library Management Setting (Configuraciones generales, como el tiempo que dura el prestamo de un artículo)
+
+La interfaz de usuario (UI) para la aplicación va a ser el **Frappe Desk**, un entorno para UI basado en el navegador y viene integrado en Frappe donde los formularios son generados automáticamente desde los modelos y los roles y permisos son aplicados.
+
+También, vamos a crear vistas webs para la librería donde los usuarios pueden buscar los artículos desde una página web.
+
+{index}

frappe/docs/user/es/tutorial/index.txt

+before
+app
+bench
+new-app
+setting-up-the-site
+start
+models
+roles
+doctypes
+naming-and-linking
+doctype-directory-structure
+users-and-records
+form-client-scripting
+controllers
+reports
+web-views
+single-doctypes
+task-runner
+conclusion

frappe/docs/user/es/tutorial/models.md

+# Creando Modelos
+
+El siguiente paso es crear los modelos que discutimos en la introducción. En Frappe, los modelos son llamados **DocTypes**. Puedes crear nuevos DocTypes desde el UI Escritorio de Frappe.  **DocTypes** son creados de campos llamados **DocField** y los permisos basados en roles son integrados dentro de los modelos, estos son llamados **DocPerms**.
+
+Cuando un DocType es guardado, se crea una nueva tabla en la base de datos. Esta tabla se nombra `tab[doctype]`.
+
+Cuando creas un **DocType** una nueva carpeta es creada en el **Module** y un archivo JSON y una platilla de un controlador en Python son creados automáticamente. Cuando modificas un DocType, el archivo JSON es modificado y cada vez que se ejecuta `bench migrate`, sincroniza el archivo JSON con la tabla en la base de datos. Esto hace que sea más facíl reflejar los cambios hechos al esquema y migrarlo.
+
+### Modo desarrollador
+
+Para crear modelos, debes setear `developer_mode` a 1 en el archivo `site_config.json` ubicados en /sites/library y ejecuta el comando `bench clear-cache` o usa el menú de usuario en el Escritorio y da click en "Recargar/Reload" para que los cambios tomen efecto. Deberías poder ver la aplicación llamada "Developer" en su escritorio.
+
+	{
+	 "db_name": "bcad64afbf",
+	 "db_password": "v3qHDeVKvWVi7s97",
+	 "developer_mode": 1
+	}
+
+{next}

frappe/docs/user/es/tutorial/naming-and-linking.md

+# Nombrando y Asociando DocType
+
+Vamos a crear otro DocType y guardarlo:
+
+1. Library Member (First Name, Last Name, Email Address, Phone, Address)
+
+<img class="screenshot" alt="Doctype Saved" src="{{docs_base_url}}/assets/img/naming_doctype.png">
+
+
+#### Nombrando DocTypes
+
+Los DocTypes pueden ser nombrados en diferentes maneras:
+
+1. Basados en un campo
+1. Basados en una serie
+1. A traves del controlador (vía código)
+1. Con un promt
+
+Esto puede ser seteado a traves del campo **Autoname**. Para el controlador, dejar en blanco.
+
+> **Search Fields**: Un DocType puede ser nombrado por serie pero seguir teniendo la necesidad de ser buscado por nombre. En nuestro caso, el Article va ser buscado por el título o el nombre del autor. Por lo que vamos a poner esos campos en el campo de search.
+
+<img class="screenshot" alt="Autonaming and Search Field" src="{{docs_base_url}}/assets/img/autoname_and_search_field.png">
+
+#### Campo de Enlace y Campo Select
+
+Las claves foraneas son específicadas en Frappe como campos **Link** (Enlace). El DocType debe ser mencionado en el area de texto de Options.
+
+En nuestro ejemplo, en el DocType de Library Transaction,tenemos que enlazar los dos DocTypes de Library Member and the Article.
+
+**Nota:** Recuerda que los campos de Enlace no son automáticamente establecidos como claves foraneas en la base de datos MariaDB, porque esto crearía un indice en la columna. Las validaciones de claves foraneas son realizadas por el Framework.
+
+<img class="screenshot" alt="Link Field" src="{{docs_base_url}}/assets/img/link_field.png">
+
+Por campos de tipo Select, como mencionamos antes, agrega varias opciones en la caja de texto **Options**, cada una en una nueva linea.
+
+<img class="screenshot" alt="Select Field" src="{{docs_base_url}}/assets/img/select_field.png">
+
+De manera similar continua haciendo los otros modelos.
+
+#### Valores enlazados
+
+Un patrón estandar es que cuando seleccionas un ID, dice **Library Member** en **Library Membership**, entonces el nombre y apellido del miembro deberian ser copiados en campos relevantes de el Doctype  Library Membership Transaction.
+
+Para hacer esto, podemos usar campos de solo lectura y en opciones, podemos especificar el nombre del link (enlace) y el campo o propiedad que deseas obtener. Para este ejempo en **Member First Name** podemos especificar `library_member.first_name`.
+
+<img class="screenshot" alt="Fetch values" src="{{docs_base_url}}/assets/img/fetch.png">
+
+### Completar los modelos
+
+En la misma forma, puedes completar todos los modelos, todos los campos deben verse de esta manera
+
+#### Article
+
+<img class="screenshot" alt="Article" src="{{docs_base_url}}/assets/img/doctype_article.png">
+
+#### Library Member
+
+<img class="screenshot" alt="Library Member" src="{{docs_base_url}}/assets/img/doctype_lib_member.png">
+
+#### Library Membership
+
+<img class="screenshot" alt="Library Membership" src="{{docs_base_url}}/assets/img/doctype_lib_membership.png">
+
+#### Library Transaction
+
+<img class="screenshot" alt="Library Transaction" src="{{docs_base_url}}/assets/img/doctype_lib_trans.png">
+
+> Asegurate de dar permiso a **Librarian** en cada DocType
+
+{next}

frappe/docs/user/es/tutorial/new-app.md

+# Creando una nueva aplicación
+
+Una vez el bench esté instalado, vas a ver dos directorios principales, `apps` and `sites`. Todas las aplicaciones van a ser instaladas en apps.
+
+Para crear una nueva aplicación, debes posicionarte en el directorio del bench y ejecutar `bench new-app {app_name}` y llenar los detalles de la aplicación. Esto a va crear los directorios y archivos necesarios para una aplicación.
+
+	$ bench new-app library_management
+	App Title (defaut: Lib Mgt): Library Management
+	App Description:  App for managing Articles, Members, Memberships and Transactions for Libraries
+	App Publisher: Frappe
+	App Email: info@frappe.io
+	App Icon (default 'octicon octicon-file-directory'): octicon octicon-book
+	App Color (default 'grey'): #589494
+	App License (default 'MIT'): GNU General Public License
+
+### Estructura de una aplicación
+
+La aplicación va a ser creada en el directorio llamado `library_management` y va a tener la siguiente estructura:
+
+	.
+	├── MANIFEST.in
+	├── README.md
+	├── library_management
+	│   ├── __init__.py
+	│   ├── config
+	│   │   ├── __init__.py
+	│   │   └── desktop.py
+	│   ├── hooks.py
+	│   ├── library_management
+	│   │   └── __init__.py
+	│   ├── modules.txt
+	│   ├── patches.txt
+	│   └── templates
+	│       ├── __init__.py
+	│       ├── generators
+	│       │   └── __init__.py
+	│       ├── pages
+	│       │   └── __init__.py
+	│       └── statics
+	├── license.txt
+	├── requirements.txt
+	└── setup.py
+
+1. `config` contiene la información de configuración de la aplicación.
+1. `desktop.py` es donde los íconos del escritorio pueden ser agregados al mismo.
+1. `hooks.py` es donde se configuran las integraciones con el entorno y otras aplicaciones.
+1. `library_management` (dentro) es un **módulo** que está contenido. En Frappe, un **módulo** es donde los modelos y controladores se almacenan.
+1. `modules.txt` contiene la lista de **módulos** en la aplicación. Cuando creas un nuevo módulo, es obligatorio que lo agregues a este archivo.
+1. `patches.txt` es donde los patches para migraciones son establecidos. Son módulos de Python referenciados usando la nomenclatura de punto.
+1. `templates` es el directorio donde son mantenidos las plantillas de vistas web. Plantillas para **Login** y otras páginas estandar estan contenidas en Frappe.
+1. `generators` son donde las plantillas para los modelos son almacenadas, donde cada instancia de modelo tiene una ruta web separada, por ejemplo un **Blog Post** donde cada post tiene una url única.  En Frappe, el manejador de plantillas utilizado es Jinja2.
+1. `pages` es donde las rutas simples son almacenadas. Por ejemplo para un tipo de página "/blog".
+
+{next}

frappe/docs/user/es/tutorial/reports.md

+# Reportes
+
+Puedes dar click en el texto que dice Reportes en el panel lateral izquierdo para ver los registros de manera tabulada.
+
+<img class="screenshot" alt="Report" src="{{docs_base_url}}/assets/img/report.png">
+
+{next}