Document Translation pt-BR

docs/docs-langs.json

@@ -4,6 +4,11 @@
       "DisplayName" : "English",
       "Code" : "en",
       "IsDefault": true
+    },
+	{
+      "DisplayName" : "Português",
+      "Code" : "pt-BR",
+      "IsDefault": false
     },
     {
       "DisplayName" : "简体中文",

docs/pt-BR/Contribution/Index.md

@@ -0,0 +1,60 @@
+## Guia de Contribuição
+
+O ABP é um projeto de [código aberto](https://github.com/abpframework) e orientado à comunidade. Este guia tem como objetivo ajudar alguém que queira contribuir com o projeto.
+
+### Contribuição de código
+
+Você sempre pode enviar solicitações pull ao repositório do Github.
+
+- Clone o [repositório ABP](https://github.com/abpframework/abp/) do Github.
+- Faça as alterações necessárias.
+- Envie uma solicitação de recebimento.
+
+Antes de fazer qualquer alteração, discuta-a sobre os [problemas](https://github.com/abpframework/abp/issues) do [Github](https://github.com/abpframework/abp/issues) . Dessa forma, nenhum outro desenvolvedor trabalhará no mesmo problema e seu PR terá uma chance melhor de ser aceito.
+
+#### Correções de bugs e aprimoramentos
+
+Você pode corrigir um bug conhecido ou trabalhar em uma melhoria planejada. Veja [a lista de problemas](https://github.com/abpframework/abp/issues) no Github.
+
+#### Solicitações de recursos
+
+Se você tem uma ideia de recurso para a estrutura ou módulos, [crie um problema](https://github.com/abpframework/abp/issues/new) no Github ou participe de uma discussão existente. Então você pode implementá-lo se for adotado pela comunidade.
+
+### Tradução de documentos
+
+Você pode traduzir a [documentação](https://abp.io/documents/) completa (incluindo esta) para o idioma materno. Nesse caso, siga estas etapas:
+
+- Clone o [repositório ABP](https://github.com/abpframework/abp/) do Github.
+- Para adicionar um novo idioma, crie uma nova pasta dentro da pasta [docs](https://github.com/abpframework/abp/tree/master/docs) . Os nomes das pastas podem ser "en", "es", "fr", "tr" e assim por diante, com base no idioma (consulte [todos os códigos de cultura](https://msdn.microsoft.com/en-us/library/hh441729.aspx) ).
+- Obtenha a [pasta "en"](https://github.com/abpframework/abp/tree/master/docs/en) como uma referência para os nomes de arquivos e a estrutura de pastas. Mantenha o mesmo nome se estiver traduzindo a mesma documentação.
+- Envie uma solicitação de recebimento (PR) depois de traduzir qualquer documento. Traduza documentos e envie PRs um por um. Não espere para terminar as traduções de todos os documentos.
+
+Alguns documentos fundamentais precisam ser traduzidos antes da publicação de um idioma no [site de documentação](https://docs.abp.io/) da [ABP](https://docs.abp.io/) :
+
+- Documentos de introdução
+- Tutoriais
+- CLI
+
+Um novo idioma é publicado após a conclusão dessas traduções mínimas.
+
+### Localização de Recursos
+
+A estrutura ABP possui um [sistema de localização](../Localization.md) flexível . Você pode criar interfaces de usuário localizadas para seu próprio aplicativo.
+
+Além disso, os módulos de estrutura e pré-construção já localizaram textos. Como exemplo, veja [os textos de localização para o pacote Volo.Abp.UI](https://github.com/abpframework/abp/blob/master/framework/src/Volo.Abp.UI/Localization/Resources/AbpUi/en.json) . Você pode criar um novo arquivo na [mesma pasta](https://github.com/abpframework/abp/tree/master/framework/src/Volo.Abp.UI/Localization/Resources/AbpUi) para traduzi-lo.
+
+- Clone o [repositório ABP](https://github.com/abpframework/abp/) do Github.
+- Crie um novo arquivo para o idioma de destino para um arquivo de texto de localização (json) (próximo ao arquivo en.json).
+- Copie todos os textos do arquivo en.json.
+- Traduzir os textos.
+- Enviar solicitação de recebimento no Github.
+
+ABP é uma estrutura modular. Portanto, existem muitos recursos de texto de localização, um por módulo. Para encontrar todos os arquivos .json, você pode procurar por "en.json" após clonar o repositório. Você também pode verificar [esta lista](https://docs.abp.io/en/abp/latest/Contribution/Localization-Text-Files) para obter uma lista de arquivos de texto de localização.
+
+### Posts e tutoriais do blog
+
+Se você decidir criar alguns tutoriais ou postagens de blog no ABP, informe-nos (criando um [problema no Github](https://github.com/abpframework/abp/issues) ), para que possamos adicionar um link ao seu tutorial / publicação na documentação oficial e podemos anunciá-lo em nossa [conta do Twitter](https://twitter.com/abpframework) .
+
+### Relatório de erro
+
+Se você encontrar algum erro, [crie um problema no repositório do Github](https://github.com/abpframework/abp/issues/new) .

docs/pt-BR/Getting-Started-Angular-Template.md

@@ -0,0 +1,126 @@
+## Introdução ao modelo de aplicativo angular
+
+Este tutorial explica como criar um novo aplicativo Angular usando o modelo de inicialização, configurar e executá-lo.
+
+### Criando um novo projeto
+
+Este tutorial usa o **ABP CLI** para criar um novo projeto. Consulte a página [Introdução](https://abp.io/get-started) para outras opções.
+
+Instale a CLI ABP usando uma janela de linha de comando, se você não tiver instalado antes:
+
+```bash
+dotnet tool install -g Volo.Abp.Cli
+```
+
+Use o `abp new`comando em uma pasta vazia para criar seu projeto:
+
+```bash
+abp new Acme.BookStore -u angular
+```
+
+> Você pode usar diferentes níveis de namespaces; por exemplo, BookStore, Acme.BookStore ou Acme.Retail.BookStore.
+
+`-u angular`A opção especifica que a estrutura da interface do usuário seja Angular. O provedor de banco de dados padrão é o EF Core. Consulte a [documentação](CLI.md) da [CLI](CLI.md) para todas as opções disponíveis.
+
+#### Pré requisitos
+
+A solução criada requer;
+
+- [Visual Studio 2017 (v15.9.0 +)](https://visualstudio.microsoft.com/tr/downloads/)
+- [.NET Core 2.2 ou superior](https://www.microsoft.com/net/download/dotnet-core/)
+- [Node v10.16 +](https://nodejs.org/)
+- [Yarn v1.17 +](https://yarnpkg.com/)
+
+### A Estrutura da Solução
+
+Abra a solução no **Visual Studio** :
+
+![livraria-visual-studio-solução](images/bookstore-visual-studio-solution-for-spa.png)
+
+A solução possui uma estrutura em camadas (baseada no [Domain Driven Design](Domain-Driven-Design.md) ) e contém projetos de teste de unidade e integração adequadamente configurados para trabalhar com o **banco de** dados de **memória** **EF Core** e **SQLite** .
+
+> Consulte o [documento do modelo do aplicativo](Startup-Templates/Application.md)  para entender a estrutura da solução em detalhes.
+
+### Cadeia de Conexão de Banco de Dados
+
+Verifique a **cadeia de conexão** no `appsettings.json`arquivo no `.HttpApi.Host`projeto:
+
+```json
+{
+  "ConnectionStrings": {
+    "Default": "Server=localhost;Database=BookStore;Trusted_Connection=True"
+  }
+}
+```
+
+A solução está configurada para usar o **Entity Framework Core** com o **MS SQL Server** . O EF Core suporta [vários](https://docs.microsoft.com/en-us/ef/core/providers/) provedores de banco de dados, para que você possa usar outro DBMS, se desejar. Mude a cadeia de conexão, se necessário.
+
+### Criar banco de dados e aplicar migrações de banco de dados
+
+Você tem duas opções para criar o banco de dados.
+
+#### Usando o aplicativo DbMigrator
+
+A solução contém um aplicativo de console (nomeado `Acme.BookStore.DbMigrator`nesta amostra) que pode criar banco de dados, aplicar migrações e propagar dados iniciais. É útil no desenvolvimento e no ambiente de produção.
+
+> `.DbMigrator`projeto tem o seu próprio `appsettings.json`. Portanto, se você alterou a cadeia de conexão acima, também deve alterar esta.
+
+Clique com o botão direito do mouse no `.DbMigrator`projeto e selecione **Definir como Projeto de Inicialização** :
+
+![definir como projeto de inicialização](images/set-as-startup-project.png)
+
+Pressione F5 (ou Ctrl + F5) para executar o aplicativo. Terá uma saída como mostrado abaixo:
+
+![definir como projeto de inicialização](images/db-migrator-app.png)
+
+#### Usando o comando EF Core Update-Database
+
+O Ef Core possui um `Update-Database`comando que cria banco de dados, se necessário, e aplica migrações pendentes. Clique com o botão direito do mouse no `.Web`projeto e selecione **Definir como Projeto de Inicialização** :
+
+![definir como projeto de inicialização](images/set-as-startup-project.png)
+
+Abra o **Console do Gerenciador de Pacotes** , selecione o `.EntityFrameworkCore.DbMigrations`projeto como **Projeto Padrão** e execute o `Update-Database`comando:
+
+![pcm-update-database](images/pcm-update-database-v2.png)
+
+Isso criará um novo banco de dados com base na cadeia de conexão configurada.
+
+> O uso da `.Migrator`ferramenta é a maneira sugerida, porque também semeia os dados iniciais para poder executar corretamente o aplicativo Web.
+
+### Executando o aplicativo
+
+#### Execute o host da API (lado do servidor)
+
+Verifique se o `.HttpApi.Host`projeto é o projeto de inicialização e o aplicativo que abrirá uma interface do usuário do Swagger:
+
+![livraria-homepage](images/bookstore-swagger-ui-host.png)
+
+Você pode ver as APIs do aplicativo e testá-las aqui. Obtenha [mais informações](https://swagger.io/tools/swagger-ui/) sobre a interface do usuário do Swagger.
+
+##### Autorização para a interface do usuário do Swagger
+
+A maioria das APIs de aplicativos requer autenticação e autorização. Se você deseja testar APIs autorizadas, vá manualmente para a `/Account/Login`página, digite `admin`como o nome de usuário e `1q2w3E*`a senha para efetuar login no aplicativo. Você também poderá executar APIs autorizadas.
+
+#### Execute o aplicativo angular (lado do cliente)
+
+Vá para a `angular`pasta, abra um terminal de linha de comando, digite o `yarn`comando (sugerimos ao gerenciador de pacotes do [yarn](https://yarnpkg.com/) enquanto o npm install também funcionará na maioria dos casos):
+
+```bash
+yarn
+```
+
+Depois que todos os módulos do nó estiverem carregados, execute `yarn start`ou `npm start`comando:
+
+```bash
+yarn start
+```
+
+Abra seu navegador favorito e vá para `localhost:4200`URL. Nome de usuário inicial é `admin`e senha é `1q2w3E*`.
+
+O modelo de inicialização inclui os módulos de **gerenciamento de** **identidade** e **gerenciamento de inquilino** . Após o login, o menu Administração estará disponível, onde você poderá gerenciar **inquilinos** , **funções** , **usuários** e suas **permissões** .
+
+> Recomendamos o [Visual Studio Code](https://code.visualstudio.com/) como editor do projeto Angular, mas você pode usar seu editor favorito.
+
+### Qual é o próximo?
+
+- [Tutorial de desenvolvimento de aplicativos](Tutorials/Angular/Part-I.md)

docs/pt-BR/Getting-Started-AspNetCore-Application.md

@@ -0,0 +1,183 @@
+# Introdução ao ABP com o aplicativo Web MVC AspNet Core
+
+Este tutorial explica como iniciar o ABP do zero com dependências mínimas. Você geralmente deseja começar com o **modelo de inicialização** .
+
+## Criar um novo projeto
+
+1. Crie um novo aplicativo da Web vazio do AspNet Core no Visual Studio:
+
+![img](images/create-new-aspnet-core-application.png)
+
+1. Selecionar modelo vazio
+
+![img](images/select-empty-web-application.png)
+
+Você pode selecionar outro modelo, mas quero mostrá-lo em um projeto claro.
+
+## Instale o pacote Volo.Abp.AspNetCore.Mvc
+
+Volo.Abp.AspNetCore.Mvc é um pacote de integração do AspNet Core MVC para ABP. Então, instale-o no seu projeto:
+
+```
+Install-Package Volo.Abp.AspNetCore.Mvc
+```
+
+## Criar o primeiro módulo ABP
+
+O ABP é uma estrutura modular e requer uma classe de **módulo de inicialização (raiz)** derivada de `AbpModule`:
+
+```csharp
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.Extensions.DependencyInjection;
+using Volo.Abp;
+using Volo.Abp.AspNetCore.Modularity;
+using Volo.Abp.AspNetCore.Mvc;
+using Volo.Abp.Modularity;
+
+namespace BasicAspNetCoreApplication
+{
+    [DependsOn(typeof(AbpAspNetCoreMvcModule))]
+    public class AppModule : AbpModule
+    {
+        public override void OnApplicationInitialization(ApplicationInitializationContext context)
+        {
+            var app = context.GetApplicationBuilder();
+            var env = context.GetEnvironment();
+
+            if (env.IsDevelopment())
+            {
+                app.UseDeveloperExceptionPage();
+            }
+
+            app.UseMvcWithDefaultRoute();
+        }
+    }
+}
+```
+
+`AppModule` é um bom nome para o módulo de inicialização de um aplicativo.
+
+Os pacotes ABP definem as classes do módulo e um módulo pode depender de outro módulo. No código acima, nosso `AppModule`depende `AbpAspNetCoreMvcModule`(definido pelo pacote Volo.Abp.AspNetCore.Mvc). É comum adicionar um `DependsOn`atributo após a instalação de um novo pacote de nuget ABP.
+
+Em vez da classe Startup, estamos configurando o pipeline do ASP.NET Core nesta classe de módulo.
+
+## A classe de inicialização
+
+O próximo passo é modificar a classe Startup para integrar ao sistema do módulo ABP:
+
+```csharp
+using System;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace BasicAspNetCoreApplication
+{
+    public class Startup
+    {
+        public IServiceProvider ConfigureServices(IServiceCollection services)
+        {
+            services.AddApplication<AppModule>();
+
+            return services.BuildServiceProviderFromFactory();
+        }
+
+        public void Configure(IApplicationBuilder app)
+        {
+            app.InitializeApplication();
+        }
+    }
+}
+```
+
+`ConfigureServices`Método alterado para retornar em `IServiceProvider`vez de `void`. Essa alteração nos permite substituir a injeção de dependência do AspNet Core por outra estrutura (consulte a seção de integração com Autofac abaixo). `services.AddApplication<AppModule>()`adiciona todos os serviços definidos em todos os módulos a partir do `AppModule`.
+
+`app.InitializeApplication()`O `Configure`método call in inicializa e inicia o aplicativo.
+
+## Olá Mundo!
+
+O aplicativo acima não faz nada. Vamos criar um controlador MVC que faz algo:
+
+```csharp
+using Microsoft.AspNetCore.Mvc;
+using Volo.Abp.AspNetCore.Mvc;
+
+namespace BasicAspNetCoreApplication.Controllers
+{
+    public class HomeController : AbpController
+    {
+        public IActionResult Index()
+        {
+            return Content("Hello World!");
+        }
+    }
+}
+```
+
+Se você executar o aplicativo, verá um "Olá, mundo!" mensagem na página.
+
+Derivado `HomeController`de em `AbpController`vez de `Controller`classe padrão . Isso não é necessário, mas a `AbpController`classe possui propriedades e métodos base úteis para facilitar seu desenvolvimento.
+
+## Usando Autofac como a estrutura de injeção de dependência
+
+Embora o sistema de Injeção de Dependência (DI) do AspNet Core seja adequado para requisitos básicos, o Autofac fornece recursos avançados, como Injeção de Propriedade e Interceptação de Método, exigidos pela ABP para executar recursos avançados da estrutura de aplicativos.
+
+Substituir o sistema DI do AspNet Core pelo Autofac e integrar ao ABP é bastante fácil.
+
+1. Instale o pacote [Volo.Abp.Autofac](https://www.nuget.org/packages/Volo.Abp.Autofac)
+
+```
+Install-Package Volo.Abp.Autofac
+```
+
+1. Adicionar `AbpAutofacModule`dependência
+
+```csharp
+[DependsOn(typeof(AbpAspNetCoreMvcModule))]
+[DependsOn(typeof(AbpAutofacModule))] //Add dependency to ABP Autofac module
+public class AppModule : AbpModule
+{
+    ...
+}
+```
+
+1. Altere a `services.AddApplication<AppModule>();`linha na `Startup`classe, como mostrado abaixo:
+
+```csharp
+services.AddApplication<AppModule>(options =>
+{
+    options.UseAutofac(); //Integrate to Autofac
+});
+```
+
+1. Atualize `Program.cs`para não usar o `WebHost.CreateDefaultBuilder()`método, pois ele usa o contêiner DI padrão:
+
+```csharp
+public class Program
+{
+    public static void Main(string[] args)
+    {
+        /*
+            https://github.com/aspnet/AspNetCore/issues/4206#issuecomment-445612167
+            CurrentDirectoryHelpers exists in: \framework\src\Volo.Abp.AspNetCore.Mvc\Microsoft\AspNetCore\InProcess\CurrentDirectoryHelpers.cs
+            Will remove CurrentDirectoryHelpers.cs when upgrade to ASP.NET Core 3.0.
+        */
+        CurrentDirectoryHelpers.SetCurrentDirectory();
+
+        BuildWebHostInternal(args).Run();
+    }
+
+    public static IWebHost BuildWebHostInternal(string[] args) =>
+        new WebHostBuilder()
+            .UseKestrel()
+            .UseContentRoot(Directory.GetCurrentDirectory())
+            .UseIIS()
+            .UseIISIntegration()
+            .UseStartup<Startup>()
+            .Build();
+}
+```
+
+## Código fonte
+
+Obter código-fonte do projeto de exemplo criada neste tutorial a partir de [aqui](https://github.com/abpframework/abp/tree/master/samples/BasicAspNetCoreApplication) .