Tutorial portuguese (#2125)

* add portugues opition on index

* add portugues folder

* translate app.md

* translate before.md

* translate title of app and before

* translate bench.md

* translate conclusion

* translate new-app.md

* translate setting-up-the-site.md

* translate start.md

* translate models.md

* translate roles.md

* translate doctypes.md

* translate naming-and-liking.md

* translate doctype-directory-structure.md

* translate users-and-records.md

* translate page form-client-scripting.md

* translate page controllers.md

* translate page reports.md

* translate page web-views.md

* translate page single-doctypes.md

* translate page taks-runner.md

* translate change cargo to role

frappe/docs/user/index.md

@@ -4,3 +4,4 @@ Select your language
 
 1. [English]({{docs_base_url}}/user/en)
 1. [Français]({{docs_base_url}}/user/fr)
+1. [Português]({{docs_base_url}}/user/pt)

frappe/docs/user/index.txt

@@ -1,2 +1,3 @@
 en
 fr
+pt

frappe/docs/user/pt/index.md

@@ -0,0 +1,3 @@
+# Develop Apps with Frappe
+
+{index}

frappe/docs/user/pt/index.txt

@@ -0,0 +1 @@
+tutorial

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

@@ -0,0 +1,9 @@
+# O que é uma aplicação
+
+Uma Aplicação em Frappe é apenas uma aplicação padrão em Python. Você pode estruturar uma aplicação Frappe da mesma forma que estrutura uma aplicação padrão do Python. Para fazer o deploy, Frappe usa o padrão Setuptools do Python, assim você pode facilmente portar e instalar o aplicativo em qualquer máquina.
+
+Frappe Framework fornece uma interface WSGI e para o desenvolvimento você pode usar o servidor embutido Werkzeug. Para a implementação em produção, recomendamos o uso do nginx e gunicorn.
+
+Frappe também tem uma arquitetura multi-tenant, a partir da base. Isso significa que você pode executar vários "sites" em sua configuração, cada um poderia estar servindo um conjunto diferente de aplicativos e usuários. O banco de dados de  cada site é separado.
+
+{next}

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

@@ -0,0 +1,47 @@
+# Antes de começar
+
+<p class="lead">Uma lista de ferramentas, tecnologias que serão muito úteis para a construção de aplicativos com Frappe.</p>
+
+Há uma série de bons tutoriais on-line e encontramos [Codecademy] (http://www.codecademy.com/) como um dos mais bonitos tutoriais, aqui há um monte de lições que você pode aprender com Codecademy
+
+---
+
+#### 1. Python
+
+O lado do servidor do Frappe é escrito em Python e é uma boa idéia para [aprender rapidamente Python] (http://www.codecademy.com/tracks/python) antes de começar a se aprofundar em Frappe. Outro bom lugar para aprender Pytohn é o [tutorial no docs.python.org](https://docs.python.org/2.7/tutorial/index.html). Note-se que o Frappe usa Python 2.7
+
+Para escrever código do lado do servidor de qualidade, você deve incluir testes automáticos. Você pode aprender as noções básicas de [test driven development (TDD) - aqui] (http://code.tutsplus.com/tutorials/beginning-test-driven-development-in-python--net-30137).
+
+---
+
+#### 2. Databases MariaDB / MySQL
+
+Você precisa entender os conceitos básicos de bancos de dados, como instalar, login, criar novos bancos de dados e consultas SQL básicas. Aqui é um [introdução muito rápido para MySQL] (https://www.digitalocean.com/community/tutorials/a-basic-mysql-tutorial) ou o [site do MariaDB para uma compreensão mais detalhada] (https://mariadb.com/kb/en/mariadb/documentation/getting-started/)
+
+---
+
+#### 3. HTML / CSS
+
+Se você está construindo interfaces de usuário, você precisará [conhecer o básico de HTML / CSS] (http://www.codecademy.com/tracks/web) e o [Framework CSS - Boostrap] (http://getbootstrap.com)
+
+---
+
+#### 4. Building UI with Javascript and JQuery
+
+Para personalizar formulários e criar novas interfaces de usuário ricas, é melhor [saber JavaScript] (http://www.codecademy.com/tracks/javascript) e a [biblioteca popular, JQuery] (http://www.codecademy.com/faixas/jQuery).
+
+---
+
+#### 5. Customizing Prints and Web pages with Jinja Templating
+
+Se estiver personalizando modelos de impressão, você precisa aprender a [línguagem Jinja Templating] (http://jinja.pocoo.org/). É uma maneira fácil de criar páginas web dinâmicas (HTML).
+
+---
+
+#### 6. Git and GitHub
+
+[Saiba como contribuir para um projeto open source usando Git e GitHub] (https://guides.github.com/activities/contributing-to-open-source/), duas grandes ferramentas para ajudá-lo a gerir o seu código e compartilha-lo com os outros.
+
+---
+
+Quando estiver pronto, [tente construir uma aplicação de exemplo em Frappe]({{docs base_url}}/user/pt/tutorial/app)

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

@@ -0,0 +1,10 @@
+# Instalando o Frappe Bench
+
+A maneira mais fácil de instalar o frappe em um sistema baseado em Unix, é utilizando o frappe-bench. Leia as instruções detalhadas sobre como instalar usando o Frappe Bench.
+
+> [https://github.com/frappe/bench](https://github.com/frappe/bench)
+
+Com Frappe Bench você será capaz de configurar e hospedar vários aplicativos e sites e vai também configurar um Virtualenv do Python de modo que você pode ter um ambiente isolado para executar seus aplicativos (e não terá conflito de versões com outros ambientes de desenvolvimento).
+
+O `bench` ferramenta de linha de comando também será instalado, o que irá ajudá-lo no desenvolvimento e na gestão da instalação.
+{next}

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

@@ -0,0 +1,6 @@
+# Conclusão
+
+
+Esperamos que este tutorial lhe de uma visão geral de como as aplicações são desenvolvidas em Frappe. O objetivo era abordar brevemente os vários aspectos do desenvolvimento de aplicações e dar uma visão ampla. Para obter ajuda em questões específicas, olhe nossa API.
+
+Para obter ajuda, faça parte da comunidade no [canal de bate-papo no Gitter](https://gitter.im/frappe/erpnext) ou no [fórum de desenvolvedores](https://discuss.erpnext.com)

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

@@ -0,0 +1,59 @@
+# Controladores
+
+O passo seguinte seria a adição de métodos e handlers de eventos para os modelos. No aplicativo, devemos assegurar que se uma Library Transaction é feita, o artigo em questão deve estar em estoque e o membro que irá emprestar o artigo deve ter um filiação válida.
+
+Para isso, podemos escrever uma validação pouco antes do objeto de Library Transaction ser salvo. Para fazer isso, abra o template `library_management/doctype/library_transaction/library_transaction.py`.
+
+Este arquivo é o controlador para o objeto Library Transaction. Nele você pode escrever métodos para:
+
+1. `before_insert`
+1. `validate` (antes de inserir ou atualizar)
+1. `on_update` (depois de salvar)
+1. `on_submit` (quando o documento é submetido)
+1. `on_cancel`
+1. `on_trash` (antes que ele esteja prestes a ser excluido)
+
+Você pode escrever métodos para esses eventos e eles serão chamados pelo framework quando o documento for salvo etc.
+
+Aqui é o controlador acabado:
+
+	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} has not been recorded as returned since {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(_("Cannot return article not issued"))
+
+Nesse script:
+
+1. Pegamos a última transação antes da data da transação atual usando a função de consulta `frappe.get_list`
+1. Se a última transação for algo que não queremos, lançamos uma exceção usando `frappe.throw`
+1. Usamos o método `_("text")` para identificar strings traduzíveis.
+
+Verifique se suas validações funcionaram, criando de novos registros.
+
+<img class="screenshot" alt="Transaction" src="{{docs_base_url}}/assets/img/lib_trans.png">
+
+#### Debugging
+
+Para Debugar, mantenha sempre o seu Console JS aberto. procurando por erros de servidor e JavaScript.
+
+Além disso, verifique a sua janela do terminal para exceções. Quaisquer  **500 Internal Server Errors** será impresso em seu terminal, onde o servidor está rodando.
+
+{next}

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

@@ -0,0 +1,31 @@
+# Estrutura de diretórios do DocType
+
+Depois de salvar os doctypes, verifique-se de que oo arquivos do modelo `.json` e `.py` foram criados no modulo `apps/library_management/library_management`. A estrutura de diretório após a criação dos modelos deve ficar assim:
+
+	.
+	├── 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/pt/tutorial/doctypes.md

@@ -0,0 +1,95 @@
+# DocType
+
+Depois de criar as Roles, vamos criar os **DocTypes**
+
+Para criar um novo **DocType**, vá para:
+
+> Developer > Documents > Doctype > New
+
+<img class="screenshot" alt="New Doctype" src="{{docs_base_url}}/assets/img/doctype_new.png">
+
+No DocType, criamos o módulo, que no nosso caso é **Library Managment**
+
+#### Adicionando Campos
+
+Na Tabela, você pode adicionar os campos (fields) do DocType (Article).
+
+Os campos são muito mais do que colunas de banco de dados, eles podem ser:
+
+1. Colunas no banco de dados
+1. Layout helpers (Seção / quebras de coluna)
+1. Tabelas filho (Tabela como tipo de uma propriedade)
+1. HTML
+1. Ações (botões)
+1. Anexos ou imagens
+
+Vamos adicionar os campos do artigo.
+
+<img class="screenshot" alt="Adding Fields" src="{{docs_base_url}}/assets/img/doctype_adding_field.png">
+
+Quando você adiciona campos, você precisa digitar o **Type**. **Label** é opcional para quebra de seção e quebra de coluna. **Name** (`fieldname`) é o nome da coluna da tabela de banco de dados e também a propriedade do controlador. Isso tem que ser um *código amigável*, ou seja, ele tem que ter caracteres minusculos e _ em vez de "". Se você deixar o nome do campo em branco, ele será ajustado automaticamente quando você salvá-lo.
+
+Você também pode definir outras propriedades do campo como se é obrigatório, apenas para leitura etc.
+
+Nós podemos adicionar os seguintes campos:
+
+1. Article Name (Data)
+2. Author (Data)
+3. Description
+4. ISBN
+5. Status (Select): Para Selecionar campos, você vai entrar nas opções. Digite **Issued** e **Available** cada um em uma nova linha na caixa de Opções. Consulte o diagrama abaixo
+6. Publisher (Data)
+7. Language (Data)
+8. Image (Attach Image)
+
+
+#### Adicionando permissões
+
+Depois de adicionar os campos, finalize e adicione uma nova linha na seção Regras de permissão. Por enquanto, vamos dar permissão de Read, Write, Create, Delete and Report, a **Librarian**. Frappe tem uma Role baseado nas permissões do modelo. Você também pode alterar as permissões posteriormente usando o **Role Permissions Manager** do **Setup**.
+
+<img class="screenshot" alt="Adding Permissions" src="{{docs_base_url}}/assets/img/doctype_adding_permission.png">
+
+#### Salvando
+
+Click no botão **Save**. Quando o botão for clicado, um popup irá te pedir um nome. De o nome de **Article** e salve o DocType.
+
+Agora logue no mysql e verifique se a tabela do banco de dados foi criada:
+
+	$ 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 você pode ver, junto com os DocFields, várias colunas padrão também foram adicionados à tabela. Importante notar aqui que, a chave primária, `name`,` owner` (o usuário que criou o registro), `creation` e` modified` (timestamps para a criação e última modificação).
+
+{next}

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

@@ -0,0 +1,37 @@
+## Escrevendo script de formulários
+
+Até agora nós criamos um sistema básico que funciona fora da caixa, sem ter que escrever nenhum código. Vamos agora escrever alguns scripts para tornar a aplicação mais rica e adicionar validações de formulários para o usuário não inserir dados incorretos.
+
+### Script no Lado do Cliente
+
+No DocType **Library Transaction**, temos um único campo de nome do membro. Não fizemos dois campos. Agora, isso poderia muito bem ser dois campos (e provavelmente deve), mas por uma questão de exemplo, vamos considerar que temos que implementar isto. Para fazer isso, teria que escrever um Handler de eventos para um evento para quando o usuário selecionar o campo `library_member`, acessar o recurso membro do servidor usando REST API e inserir os valores no formulário.
+
+Para iniciar o script, na pasta `library_management/doctype/library_transaction`, crie um novo arquivo `library_transaction.js`. Este arquivo será executado automaticamente quando a primeiro Library Transaction for aberta pelo usuário. Portanto, neste arquivo, podemos ligar os eventos e escrever outras funções.
+
+#### 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*)** é utilizado para ligar um handler ao evento quando a propriedade library_member for definida.
+1. No handler, nós desencadear uma chamada AJAX para `frappe.client.get`. Em resposta obtemos o objeto solicitado como JSON. [Saiba mais sobre a API](/frappe/user/en/guides/integration/rest_api).
+1. Utilizando **frappe.model.set_value(*doctype*, *name*, *fieldname*, *value*)** Nós inserimos o valor no formulário.
+
+**Observação:** Para verificar se o script funciona, lembre-se de 'recarregar' a página antes de testar seu script. mudanças no script do cliente não são captadas automaticamente quando você está no modo de desenvolvedor..
+
+{next}

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

@@ -0,0 +1,33 @@
+# Frappe Tutorial
+
+In this guide we will show you how to create an application from scratch using **Frappe**. Using the example of a Library Management System, we will cover:
+
+1. Installation
+1. Making a New App
+1. Making Models
+1. Creating Users and Records
+1. Creating Controllers
+1. Creating Web Views
+1. Setting Hooks and Tasks
+
+## Who is This For?
+
+This guide is intended for software developers who are familiar with how the web applications are built and served. Frappe Framework is built on Python and uses MariaDB database and for creating web views, HTML/CSS/Javascript is used. So it would be great if you are familiar with all these technologies. At minimum if you have never used Python before, you should take a quick tutorial before your use this Guide.
+
+Frappe uses the git version control system on GitHub. It is also important that you are familiar with basic git and have an account on GitHub to manage your applications.
+
+## Example
+
+For this guide book, we will build a simple **Library Management** application. In this application we will have models:
+
+1. Article (Book or any other item that can be loaned)
+1. Library Member
+1. Library Transaction (Issue or Return of an article)
+1. Library Membership (A period in which a member is allowed to transact)
+1. Library Management Setting (Global settings like period of loan)
+
+The user interface (UI) for the librarian will be the **Frappe Desk**, a built-in browser based UI environment where forms are automatically generated from the models and roles and permissions are also applied.
+
+We will also create web views for library where users can browse articles from a website.
+
+{index}

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

@@ -0,0 +1,19 @@
+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/pt/tutorial/models.md

@@ -0,0 +1,19 @@
+# Criando modelos
+
+O próximo passo é criar os modelos como discutimos na introdução. Em Frappe, os modelos são chamados **DocTypes**. Você pode criar novos doctypes atravez da interface do Desk. **DocTypes** são feitos de campos chamados **DocField** e de permissões com base nas permissões que são integrados nos modelos, estes são chamados **DocPerms**.
+
+Quando um DocType é salvo, uma nova tabela é criada no banco de dados. Esta tabela é nomeado como `tab[doctype]`.
+
+Quando você cria um **DocType** uma nova pasta é criada no **Módulo** e um arquivo JSON do modelo e um controlador template em Python são criados automaticamente. Quando você atualizar o DocType, o arquivo modelo JSON é atualizado e quando o `bench migrate` é executado, ele é sincronizado com o banco de dados. Isto torna mais fácil para propagar alterações de schema e migrar.
+
+### Modo Desenvolvedor
+
+Para criar modelos, você deve definir `developer_mode` como 1 no arquivo `site_config.json` localizado em /sites/library e executar o comando `bench clear-cache` ou use o menu de usuário na interface do usuário e clique em "Atualizar" para que as alterações entrem em vigor. Agora você deve ver o aplicativo "Developer" em sua Desk
+
+	{
+	 "db_name": "bcad64afbf",
+	 "db_password": "v3qHDeVKvWVi7s97",
+	 "developer_mode": 1
+	}
+
+{next}

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

@@ -0,0 +1,71 @@
+# Nomeando e vinculando DocType
+
+Em seguida, vamos criar outro DocType e salva-lo também:
+
+1. Library Member (First Name, Last Name, Email ID, Phone, Address)
+
+<img class="screenshot" alt="Doctype Saved" src="{{docs_base_url}}/assets/img/naming_doctype.png">
+
+
+#### Nomeação de DocTypes
+
+DocTypes podem ser nomeados de diferentes formas:
+
+1. Com base em um campo
+1. Com base numa série
+1. Pelo controlador (Código)
+1. Prompt
+
+Isso pode ser definido através do preenchimento do campo **Autoname**. Para o controlador, deixe em branco.
+
+> **Search Fields**: A DocType pode ser nomeado em uma série, mas ele ainda precisa ser pesquisado por nome. No nosso caso, o artigo será procurado pelo título ou o nome do autor. Portanto, este pode ser inserido no campo de pesquisa.
+
+<img class="screenshot" alt="Autonaming and Search Field" src="{{docs_base_url}}/assets/img/autoname_and_search_field.png">
+
+#### Vinculando e selecionando campos
+
+As chaves estrangeiras são especificados no Frappe como um tipo de campo **Link**. O DocType alvo deve ser mencionado na área de Opções de texto.
+
+No nosso exemplo, na Library Transaction DocType, temos que ligar o Membro da Biblioteca e o artigo.
+
+**Observação:** Lembre-se que os campos link não são automaticamente configurados como chaves estrangeiras no banco de dados MariaDB, porque isso vai implicitamente indexar a coluna. Isto pode não ser ideal, mas, a validação de chave estrangeira é feito pelo Framework.
+
+<img class="screenshot" alt="Link Field" src="{{docs_base_url}}/assets/img/link_field.png">
+
+Para campos de multipla escolha, como mencionamos anteriormente, adicione as várias opções na caixa de entrada **Options**, cada opção em uma nova linha.
+
+<img class="screenshot" alt="Select Field" src="{{docs_base_url}}/assets/img/select_field.png">
+
+Fazer o mesmo para outros modelos.
+
+#### Vinculando valores
+
+Um modelo padrão é quando você seleciona um ID, **Library Member** na **Library Membership**, então, o primeiro e o ultimo nome dos membros devem ser copiados para os campos adequados ao gravar na Library Membership Transaction.
+
+Para fazer isso, podemos usar campos de somente leitura e de opções, podemos definir o nome do link e o nome do campo da propriedade que deseja buscar. Para este exemplo no **Member First Name** podemos definir `library_member.first_name`
+
+<img class="screenshot" alt="Fetch values" src="{{docs_base_url}}/assets/img/fetch.png">
+
+### Complete os modelos
+
+Da mesma forma, você pode completar todos os modelos de modo que os campos finais fiquem parecido com este:
+
+#### 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">
+
+> Lembre-se de dar permissões para **Librarian** em cada DocType
+
+{next}

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

@@ -0,0 +1,54 @@
+# Crie um novo aplicativo
+
+Uma vez que o banco ja estiver instalado, você verá duas pastas principais, `apps` e` sites`. Todos os aplicativos serão instalados em apps.
+
+Para criar uma nova aplicação, vá para a pasta do bench e execute, `bench new-app {app_name}` e preencha os detalhes sobre o aplicativo. Isto irá criar uma aplicação base para você.
+
+	$ 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
+
+### Estrutura do aplicativo
+
+O aplicativo será criado em uma pasta chamada `library_management` e terá a seguinte estrutura::
+
+	.
+	├── 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` pasta que contém as informações de configuração do aplicativo
+1. `desktop.py` é onde os ícones da área de trabalho pode ser adicionado ao Desk
+1. `hooks.py` é onde integrações com o ambiente da aplicação e outras aplicações é mencionada.
+1. `library_management` (Interior) é um **módulo** que foi criado. Em Frappe, um **módulo** é onde os arquivos do modelo e do controlador residem.
+1. `modules.txt` contém a lista dos **módulos** do aplicativo. Quando você cria um novo módulo, é necessário que você atualize este arquivo.
+1. `patches.txt` é o lugar onde os patches de migração são escritos. Eles são referências de módulos Python utilizando a notação de ponto.
+1. `templates` é a pasta onde os modelos de web view são mantidos. Modelos para **Login** e outras páginas padrão são criadas pelo frappe.
+1. `generators` é onde os templates para os modelos são mantidas, onde cada instância de modelo tem uma rota web separada, por exemplo, um **Post de um Blog**, onde cada post tem a sua única url web. Em Frappe, o mecanismo de modelagem utilizada é o Jinja2
+1. `pages` É onde uma única rota para os modelos são mantidas. Por exemplo, para um "/blog" tipo da página.
+
+{next}

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

@@ -0,0 +1,7 @@
+# Relatórios
+
+Você também pode clicar sobre o texto Relatórios na barra lateral (esquerda) para ver os registros tabulados
+
+<img class="screenshot" alt="Report" src="{{docs_base_url}}/assets/img/report.png">
+
+{next}

frappe/docs/user/pt/tutorial/roles.md

@@ -0,0 +1,14 @@
+# Criando Roles
+
+Antes de criar modelos, devemos criar roles para que possamos definir as permissões do modelo. Há dois roles que nós iremos criar:
+
+1. Librarian
+1. Library Member
+
+Para criar um novo roles, vá para:
+
+> Setup > Users > Role > New
+
+<img class="screenshot" alt="Adding Roles" src="{{docs_base_url}}/assets/img/roles_creation.png">
+
+{next}

frappe/docs/user/pt/tutorial/setting-up-the-site.md

@@ -0,0 +1,53 @@
+# Configurando o site
+
+Vamos criar um novo site e chamá-lo de `library`.
+
+Você pode instalar um novo site, pelo comando `bench new-site library`
+
+Isto irá criar uma nova pasta para o site e um banco de dados e instalar o `frappe` (que também é uma aplicação!) No novo site. A aplicação `frappe` tem dois módulos embutidos **Core** e **WebSite**. O módulo de Core contém os modelos básicos para a aplicação. Frappe é uma estrutura como as pilhas e vem com um monte de modelos internos. Estes modelos são chamados doctypes **Mais sobre isso mais tarde**.
+
+	$ bench new-site library
+	MySQL root password:
+	Installing frappe...
+	Updating frappe                     : [========================================]
+	Updating country info               : [========================================]
+	Set Administrator password:
+	Re-enter Administrator password:
+	Installing fixtures...
+	*** Scheduler is disabled ***
+
+### Estrututa do Site
+
+Uma nova pasta chamada `library` será criado na pasta` sites`. Aqui está a estrutura de pastas padrão para um site.
+
+	.
+	├── locks
+	├── private
+	│   └── backups
+	├── public
+	│   └── files
+	└── site_config.json
+
+1. `public/files` é onde os arquivos enviados pelo usuário são armazenados.
+1. `private/backups` é onde os backups são despejados
+1. `site_config.json` é onde as configurações a nível do site são mantidas.
+
+### Configurações padrão do site
+
+No caso de você ter vários sites em seu bench use `bench use [site_name]` para definir o site padrão.
+
+Exemplo:
+
+	$ bench use library
+
+### Instalar App
+
+Agora vamos instalar nosso app `library_management` no nosso site `library`
+
+1. Instale library_management no library com: `bench --site [site_name] install-app [app_name]`
+
+Exemplo:
+
+	$ bench --site library install-app library_management
+
+{next}

frappe/docs/user/pt/tutorial/single-doctypes.md

@@ -0,0 +1,9 @@
+# Single DocTypes
+
+A aplicação irá normalmente têm uma página de configurações. Em nossa aplicação, podemos definir uma página onde podemos definir o período de empréstimo. Também precisamos salvar esta propriedade. Em Frappe, isso pode ser feito usando um tipo DocType **Single** . Um DocType Single é como o padrão Singleton em Java. É um objecto com uma única instância. Vamos chamar isso de **Library Managment Settings**.
+
+Para criar um DocType Single, marque a propriedade **Is Single** como verdadeira.
+
+<img class="screenshot" alt="Single Doctypes" src="{{docs_base_url}}/assets/img/tab_single.png">
+
+{next}

frappe/docs/user/pt/tutorial/start.md

@@ -0,0 +1,31 @@
+# Iniciando o Bench
+
+Agora podemos logar e verificar se tudo funcionou.
+
+Para iniciar o servidor de desenvolvimento, digite `bench start`
+
+	$ bench start
+	13:58:51 web.1        | started with pid 22135
+	13:58:51 worker.1     | started with pid 22136
+	13:58:51 workerbeat.1 | started with pid 22137
+	13:58:52 web.1        |  * Running on http://0.0.0.0:8000/
+	13:58:52 web.1        |  * Restarting with reloader
+	13:58:52 workerbeat.1 | [2014-09-17 13:58:52,343: INFO/MainProcess] beat: Starting...
+
+Agora você pode abrir o seu navegador e ir para `http://localhost:8000`. Você deve ver esta página de login, se tudo correu bem:
+
+<img class="screenshot" alt="Login Screen" src="{{docs_base_url}}/assets/img/login.png">
+
+Agora logue com :
+
+Login ID: **Administrator**
+
+Senha : **Use a senha que foi criada durante a instalação**
+
+Quando voce logar, voce deverá ver o "Desk" da pagine home
+
+<img class="screenshot" alt="Desk" src="{{docs_base_url}}/assets/img/desk.png">
+
+Como você pode ver, o básico do sistema Frappe vem com vários aplicativos pré-carregados como coisas a fazer, o Gerenciador de arquivos etc. Esses aplicativos podem ser integrados no fluxo de trabalho do app à medida que progredimos.
+
+{next}

frappe/docs/user/pt/tutorial/task-runner.md

@@ -0,0 +1,77 @@
+# Tarefas agendadas
+
+Finalmente, uma aplicação também tem que enviar notificações de e-mail e fazer outros tipos de tarefas agendadas. Em Frappe, se você instalou o bench, o task / scheduler foi instalado via Celery usando Redis Queue.
+
+Para adicionar um novo task handler, vá para `hooks.py` e adicione um novo handler. Handlers padrão são os `all`,` daily`, `weekly`,` monthly`. O handler `all` é chamado a cada 3 minutos por padrão.
+
+	# Scheduled Tasks
+	# ---------------
+
+	scheduler_events = {
+		"daily": [
+			"library_management.tasks.daily"
+		],
+	}
+
+Aqui podemos apontar para uma função Python e esta função será executada todos os dias. Vejamos como é essa função:
+
+	# Copyright (c) 2013, Frappe
+	# For license information, please see license.txt
+
+	from __future__ import unicode_literals
+	import frappe
+	from frappe.utils import datediff, nowdate, format_date, add_days
+
+	def daily():
+		loan_period = frappe.db.get_value("Library Management Settings",
+			None, "loan_period")
+
+		overdue = get_overdue(loan_period)
+
+		for member, items in overdue.iteritems():
+			content = """<h2>Following Items are Overdue</h2>
+			<p>Please return them as soon as possible</p><ol>"""
+
+			for i in items:
+				content += "<li>{0} ({1}) due on {2}</li>".format(i.article_name,
+					i.article,
+					format_date(add_days(i.transaction_date, loan_period)))
+
+			content += "</ol>"
+
+			recipient = frappe.db.get_value("Library Member", member, "email_id")
+			frappe.sendmail(recipients=[recipient],
+				sender="test@example.com",
+				subject="Library Articles Overdue", content=content, bulk=True)
+
+	def get_overdue(loan_period):
+		# check for overdue articles
+		today = nowdate()
+
+		overdue_by_member = {}
+		articles_transacted = []
+
+		for d in frappe.db.sql("""select name, article, article_name,
+			library_member, member_name
+			from `tabLibrary Transaction`
+			order by transaction_date desc, modified desc""", as_dict=1):
+
+			if d.article in articles_transacted:
+				continue
+
+			if d.transaction_type=="Issue" and \
+				datediff(today, d.transaction_date) > loan_period:
+				overdue_by_member.setdefault(d.library_member, [])
+				overdue_by_member[d.library_member].append(d)
+
+			articles_transacted.append(d.article)
+
+Nós podemos colocar o código acima em qualquer módulo Python acessível. A rota é definida em `hooks.py`, portanto, para os nossos propósitos, iremos colocar esse código em `library_management/tasks.py`.
+
+Observação:
+
+1. Nós pegamos o loan period de **Library Management Settings** usando `frappe.db.get_value`.
+1. Nós rodamos uma query no banco de dados com `frappe.db.sql`
+1. O email foi enviado via `frappe.sendmail`
+
+{next}

frappe/docs/user/pt/tutorial/users-and-records.md

@@ -0,0 +1,55 @@
+# Fazendo Usuários e Registros
+
+Agora que já criamos os modelos, podemos começar diretamente criando registros usando a interface Desk do Frappe. Você não precisa criar Views! Views no Frappe são geradas automaticamente com base nas propriedades do DocType.
+
+### 4.1 Criando Usuarios
+
+Para criar registros, vamos primeiro criar um usuário. Para criar um usuário, vá para:
+
+> Setup > Users > User > New
+
+Crie um novo usuário e definá o nome, o primeiro nome e uma nova senha.
+
+Também de as roles de Librarian e Library Member para este usuario
+
+<img class="screenshot" alt="Add User Roles" src="{{docs_base_url}}/assets/img/add_user_roles.png">
+
+Agora saia e se autentique usando o novo ID de usuário e senha.
+
+### 4.2 Criando registros
+
+Você vai ver agora um ícone para o módulo de Library Management. Clique nesse ícone e você verá a página do modelo:
+
+<img class="screenshot" alt="Library Management Module" src="{{docs_base_url}}/assets/img/lib_management_module.png">
+
+Aqui você pode ver os doctypes que criamos para a aplicação. Vamos começar a criar alguns registros.
+
+Primeiro, vamos criar um novo artigo:
+
+<img class="screenshot" alt="New Article" src="{{docs_base_url}}/assets/img/new_article_blank.png">
+
+Aqui você vai ver que o DocType que você tinha criado foi processado como um formulário. As validações e outras regras também serão aplicadas conforme projetado. Vamos preencher um artigo.
+
+<img class="screenshot" alt="New Article" src="{{docs_base_url}}/assets/img/new_article.png">
+
+Você também pode adicionar uma imagem.
+
+<img class="screenshot" alt="Attach Image" src="{{docs_base_url}}/assets/img/attach_image.gif">
+
+Agora vamos criar um novo membro:
+
+<img class="screenshot" alt="New Library Member" src="{{docs_base_url}}/assets/img/new_member.png">
+
+Depois disso, vamos criar um novo registro de membership para o membro.
+
+Aqui se você se lembra, nós tinhamos definido os valores do primeiro e do ultimo nome do membro para ser diretamente obtido a partir dos registros de membros e, logo que você selecionar o ID de membro, os nomes serão atualizados.
+
+<img class="screenshot" alt="New Library Membership" src="{{docs_base_url}}/assets/img/new_lib_membership.png">
+
+Como você pode ver que a data é formatada como ano-mês-dia, que é um formato de sistema. Para definir/mudar a data, hora e número de formatos, acesse
+
+> Setup > Settings > System Settings
+
+<img class="screenshot" alt="System Settings" src="{{docs_base_url}}/assets/img/system_settings.png">
+
+{next}

frappe/docs/user/pt/tutorial/web-views.md

@@ -0,0 +1,64 @@
+# Web Views
+
+Frappe tem dois ambientes de usuário principais, o Desk e o Web. Desk é um ambiente UI controlado com uma rica aplicação AJAX e a web usa template HTML tradicional que serve para consumo público. Web Views também podem ser gerados para criar views mais controladas para os usuários que pode fazer o login mas ainda não têm acesso à Desk.
+
+Em Frappe, Web Views são geridas por modelos e eles geralmente estão na pasta `templates`. Existem 2 tipos principais de templates.
+
+1. Pages: Estes são Jinja Templates, onde existe uma única view para uma única rota web, por exemplo, `/blog`.
+2. Generators: Estes são templates em que cada instância de um DocType tem uma rota web separada `/blog/a-blog`, `blog/b-blog` etc.
+3. Lists and Views: Estas são listas e views padrões com a rota `[doctype]/[name]` e são processadas com base na permissão.
+
+### Standard Web Views
+
+> Esta funcionalidade ainda esta em desenvolvimento.
+
+Vamos dar uma olhada na standard Web Views:
+
+Se você estiver logado como usuário de teste, vá para `/article` e você deverá ver a lista de artigos:
+
+![Web List]({{docs_base_url}}/assets/img/guide/26-web-list.png)
+
+Clique em um artigo e você vai ver uma Web View padrão
+
+![Web List]({{docs_base_url}}/assets/img/guide/26-web-view.png)
+
+Agora, se você quiser fazer uma List View melhor para o artigo, crie um arquivo chamado `list_item.html` na pasta `library_management/doctype/article`. Aqui está um exemplo de arquivo:
+
+	{% raw %}<div class="row">
+		<div class="col-sm-4">
+			<a href="/Article/{{ doc.name }}">
+				<img src="{{ doc.image }}"
+					class="img-responsive" style="max-height: 200px">
+			</a>
+		</div>
+		<div class="col-sm-4">
+			<a href="/Article/{{ doc.name }}"><h4>{{ doc.article_name }}</h4></a>
+			<p>{{ doc.author }}</p>
+			<p>{{ (doc.description[:200] + "...")
+				if doc.description|len > 200 else doc.description }}</p>
+			<p class="text-muted">Publisher: {{ doc.publisher }}</p>
+		</div>
+	</div>{% endraw %}
+
+
+Aqui, você vai ter todas as propriedades do artigo no objeto `doc`.
+
+A List View atualizada se parece com isso!
+
+![Web List]({{docs_base_url}}/assets/img/guide/27-web-view-list.png)
+
+#### Home Page
+
+Frappe também tem um fluxo de trabalho de inscrição built-in que também inclui inscrições de terceiros via Google, Facebook e GitHub. Quando um usuário se inscreve na web, ele não tem acesso à interface Desk por padrão.
+
+> Para permitir o acesso do usuário ao Desk, abra as configurações pelo Setup > User e defina o usuário como "System User"
+
+Agora, para os não usuários do sistema, podemos definir uma home page para quando eles fizerem login via `hooks.py` com baseado na Role.
+
+Para quando os membros da biblioteca entrarem, eles devem ser redirecionado para a página `article`, para abrir o arquivo `library_management/hooks.py` adicione:
+
+	role_home_page = {
+		"Library Member": "article"
+	}
+
+{next}