From 515de2f00e98beb96c66884dba99648a06ea7a06 Mon Sep 17 00:00:00 2001 From: "Felipe A. de Almeida" Date: Sat, 26 Jun 2021 15:52:47 -0300 Subject: [PATCH 1/6] #9436 - Translation started --- docs/pt-BR/MongoDB.md | 466 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 466 insertions(+) create mode 100644 docs/pt-BR/MongoDB.md diff --git a/docs/pt-BR/MongoDB.md b/docs/pt-BR/MongoDB.md new file mode 100644 index 0000000000..08c07c2ad7 --- /dev/null +++ b/docs/pt-BR/MongoDB.md @@ -0,0 +1,466 @@ +# Integração do MongoDB + +Este documento explica como integrar e configurar o MongoDB como um provedor de banco de dados para aplicações baseadas no ABP. + +## Instalação + +`Volo.Abp.MongoDB` é o pacote nuget principal para a integração do MongoDB. Instale-o em seu projeto (para uma aplicação em camadas, será sua camada de dados ou infraestrutura): + +``` +Install-Package Volo.Abp.MongoDB +``` + +Então adicione a dependência de módulo `AbpMongoDbModule` para o seu [module](Module-Development-Basics.md): + +```c# +using Volo.Abp.MongoDB; +using Volo.Abp.Modularity; + +namespace MyCompany.MyProject +{ + [DependsOn(typeof(AbpMongoDbModule))] + public class MyModule : AbpModule + { + //... + } +} +``` + +## Criando um Mongo Db Context + +ABP apresenta o conceito **Mongo Db Context** (que é semelhante ao Entity Framework Core DbContext) para tornar mais fácil usar coleções e configurá-las. Um exemplo é mostrado abaixo: + +```c# +public class MyDbContext : AbpMongoDbContext +{ + public IMongoCollection Questions => Collection(); + + public IMongoCollection Categories => Collection(); + + protected override void CreateModel(IMongoModelBuilder modelBuilder) + { + base.CreateModel(modelBuilder); + + //Personalize a configuração para as suas collections. + } +} +``` + +* É derivado da classe `AbpMongoDbContext`. +* Adiciona uma propriedade pública `IMongoCollection` para cada mongo collection. Por padrão ABP usa essas propriedades para criar repositórios padrão. +* Substituir o método `CreateModel` permite definir a configuração da collection. + +### Configurar o Mapeamento para uma Collection + +ABP registra automaticamente entidades MongoDB client library para todas propriedades `IMongoCollection` em seu DbContext. Para o exemplo acima, as entidades `Question` e `Category` são registradas automaticamente. + +Para cada entidade registrada, chama `AutoMap()` e configura propriedades conhecidas de sua entidade. Por exemplo, se sua entidade implementa uma interface `IHasExtraProperties` (que já está implementada para cada raiz agregada por padrão), ele configura automaticamente `ExtraProperties`. + +Portanto, na maioria das vezes, você não precisa configurar explicitamente o registro de suas entidades. No entanto, se você precisar, pode fazer isso sobrescrevendo o método `CreateModel` em seu DbContext. Exemplo: + +````csharp +protected override void CreateModel(IMongoModelBuilder modelBuilder) +{ + base.CreateModel(modelBuilder); + + modelBuilder.Entity(b => + { + b.CollectionName = "MyQuestions"; //Define o nome da collection + b.BsonMap.UnmapProperty(x => x.MyProperty); //Ignora 'MyProperty' + }); +} +```` + +Este exemplo altera o nome da collection mapeada para 'MyQuestions' no banco de dados e ignora uma propriedade na classe `Question`. + +Se você só precisa configurar o nome da collection, você também pode usar o atributo `[MongoCollection]` para a collection em seu DbContext. Exemplo: + +````csharp +[MongoCollection("MyQuestions")] //Define o nome da collection +public IMongoCollection Questions => Collection(); +```` + +### Configurar a Seleção da String de Conexão + +Se você tiver vários bancos de dados em seu aplicativo, você pode configurar o nome da string de conexão para o seu DbContext usando o atributo `[ConnectionStringName]`. Exemplo: + +````csharp +[ConnectionStringName("MySecondConnString")] +public class MyDbContext : AbpMongoDbContext +{ + +} +```` + +Se você não configurar, a string de conexão `Default` é usada. Se você configurar um nome de string de conexão, mas não definir este nome da string de conexão na configuração da aplicação, então ele retorna para a string de conexão `Default`. + +## Registrando DbContext para Injeção de Dependência + +Use o método `AddAbpDbContext` em seu module para registrar sua classe DbContext para o sistema de [injeção de dependência](Dependency-Injection.md). + +```c# +using Microsoft.Extensions.DependencyInjection; +using Volo.Abp.MongoDB; +using Volo.Abp.Modularity; + +namespace MyCompany.MyProject +{ + [DependsOn(typeof(AbpMongoDbModule))] + public class MyModule : AbpModule + { + public override void ConfigureServices(ServiceConfigurationContext context) + { + context.Services.AddMongoDbContext(); + + //... + } + } +} +``` + +### Adicionar Repositórios Padrão + +O ABP pode criar automaticamente [repositórios genéricos](Repositories.md) padrão para as entidades em seu DbContext. Basta usar a opção `AddDefaultRepositories()` no registro: + +````C# +services.AddMongoDbContext(options => +{ + options.AddDefaultRepositories(); +}); +```` + +Isso criará um repositório para cada [aggregate root entity](Entities.md) (classes derivadas de `AggregateRoot`) por padrão. Se você quiser criar repositórios para outras entidades também, em seguida defina `includeAllEntities` para `true`: + +```c# +services.AddMongoDbContext(options => +{ + options.AddDefaultRepositories(includeAllEntities: true); +}); +``` + +Então você pode injetar e usar `IRepository` nas suas services. Suponha que você tenha uma entidade `Book` com a chave primária `Guid`: + +```csharp +public class Book : AggregateRoot +{ + public string Name { get; set; } + + public BookType Type { get; set; } +} +``` + +(`BookType` é um simples `enum` aqui) E você deseja criar uma nova entidade `Book` em uma [domain service](Domain-Services.md): + +```csharp +public class BookManager : DomainService +{ + private readonly IRepository _bookRepository; + + public BookManager(IRepository bookRepository) //injetar repositório padrão + { + _bookRepository = bookRepository; + } + + public async Task CreateBook(string name, BookType type) + { + Check.NotNullOrWhiteSpace(name, nameof(name)); + + var book = new Book + { + Id = GuidGenerator.Create(), + Name = name, + Type = type + }; + + await _bookRepository.InsertAsync(book); //Use um método de repositório padrão + + return book; + } +} +``` + +Este exemplo usa o método `InsertAsync` para inserir uma nova entity no banco de dados. + +### Adicionar Repositórios Personalizados + +Repositories genéricos padrão são poderosos e suficiente na maioria dos casos (uma vez que implementam `IQueryable`). No entanto, pode ser necessário criar um repositório customizado para adicionar seus próprios métodos de repositório. + +Suponha que você deseja excluir todos os books por type. É sugerido definir uma interface para seu repositório personalizado: + +```csharp +public interface IBookRepository : IRepository +{ + Task DeleteBooksByType( + BookType type, + CancellationToken cancellationToken = default(CancellationToken) + ); +} +``` + +Você geralmente vai querer derivar de `IRepository` para herdar métodos de repository padrão. No entanto, você não precisa. As interfaces de repository são definidas na camada de domínio de uma aplicação em camadas. Elas são implementadas na camada de dados ou infraestrutura (projeto `MongoDB` em um [startup template](https://abp.io/Templates)). + +Exemplo de implementação da interface `IBookRepository`: + +```csharp +public class BookRepository : + MongoDbRepository, + IBookRepository +{ + public BookRepository(IMongoDbContextProvider dbContextProvider) + : base(dbContextProvider) + { + } + + public async Task DeleteBooksByType( + BookType type, + CancellationToken cancellationToken = default(CancellationToken)) + { + var collection = await GetCollectionAsync(cancellationToken); + await collection.DeleteManyAsync( + Builders.Filter.Eq(b => b.Type, type), + cancellationToken + ); + } +} +``` + +Agora é possível [injetar](Dependency-Injection.md) a `IBookRepository` e usar o método `DeleteBooksByType` quando necessário. + +#### Substituir Repository Genérica Padrão + +Mesmo se você criar um repository personalizado, você ainda pode injetar o repository genérico padrão (`IRepository` para este exemplo). A implementação do repository padrão não usará a classe que você criou. + +If you want to replace default repository implementation with your custom repository, do it inside `AddMongoDbContext` options: + +```csharp +context.Services.AddMongoDbContext(options => +{ + options.AddDefaultRepositories(); + options.AddRepository(); //Replaces IRepository +}); +``` + +This is especially important when you want to **override a base repository method** to customize it. For instance, you may want to override `DeleteAsync` method to delete an entity in a more efficient way: + +```csharp +public async override Task DeleteAsync( + Guid id, + bool autoSave = false, + CancellationToken cancellationToken = default) +{ + //TODO: Custom implementation of the delete method +} +``` + +### Access to the MongoDB API + +In most cases, you want to hide MongoDB APIs behind a repository (this is the main purpose of the repository). However, if you want to access the MongoDB API over the repository, you can use `GetDatabaseAsync()`, `GetCollectionAsync()` or `GetAggregateAsync()` extension methods. Example: + +```csharp +public class BookService +{ + private readonly IRepository _bookRepository; + + public BookService(IRepository bookRepository) + { + _bookRepository = bookRepository; + } + + public async Task FooAsync() + { + IMongoDatabase database = await _bookRepository.GetDatabaseAsync(); + IMongoCollection books = await _bookRepository.GetCollectionAsync(); + IAggregateFluent bookAggregate = await _bookRepository.GetAggregateAsync(); + } +} +``` + +> Important: You must reference to the `Volo.Abp.MongoDB` package from the project you want to access to the MongoDB API. This breaks encapsulation, but this is what you want in that case. + +### Transactions + +MongoDB supports multi-document transactions starting from the version 4.0 and the ABP Framework supports it. However, the [startup template](Startup-templates/Index.md) **disables** transactions by default. If your MongoDB **server** supports transactions, you can enable the it in the *YourProjectMongoDbModule* class: + +```csharp +Configure(options => +{ + options.TransactionBehavior = UnitOfWorkTransactionBehavior.Auto; +}); +``` + +> Or you can delete this code since this is already the default behavior. + +### Tópicos Avançados + +### Controlling the Multi-Tenancy + +If your solution is [multi-tenant](Multi-Tenancy.md), tenants may have **separate databases**, you have **multiple** `DbContext` classes in your solution and some of your `DbContext` classes should be usable **only from the host side**, it is suggested to add `[IgnoreMultiTenancy]` attribute on your `DbContext` class. In this case, ABP guarantees that the related `DbContext` always uses the host [connection string](Connection-Strings.md), even if you are in a tenant context. + +**Example:** + +````csharp +[IgnoreMultiTenancy] +public class MyDbContext : AbpMongoDbContext +{ + ... +} +```` + +Do not use the `[IgnoreMultiTenancy]` attribute if any one of your entities in your `DbContext` can be persisted in a tenant database. + +> When you use repositories, ABP already uses the host database for the entities don't implement the `IMultiTenant` interface. So, most of time you don't need to `[IgnoreMultiTenancy]` attribute if you are using the repositories to work with the database. + +#### Set Default Repository Classes + +Default generic repositories are implemented by `MongoDbRepository` class by default. You can create your own implementation and use it for default repository implementation. + +First, define your repository classes like that: + +```csharp +public class MyRepositoryBase + : MongoDbRepository + where TEntity : class, IEntity +{ + public MyRepositoryBase(IMongoDbContextProvider dbContextProvider) + : base(dbContextProvider) + { + } +} + +public class MyRepositoryBase + : MongoDbRepository + where TEntity : class, IEntity +{ + public MyRepositoryBase(IMongoDbContextProvider dbContextProvider) + : base(dbContextProvider) + { + } +} +``` + +First one is for [entities with composite keys](Entities.md), second one is for entities with single primary key. + +It's suggested to inherit from the `MongoDbRepository` class and override methods if needed. Otherwise, you will have to implement all standard repository methods manually. + +Now, you can use `SetDefaultRepositoryClasses` option: + +```csharp +context.Services.AddMongoDbContext(options => +{ + options.SetDefaultRepositoryClasses( + typeof(MyRepositoryBase<,>), + typeof(MyRepositoryBase<>) + ); + //... +}); +``` + +#### Definir classe base MongoDbContext ou Interface para Repositories padrão + +If your MongoDbContext inherits from another MongoDbContext or implements an interface, you can use that base class or interface as the MongoDbContext for default repositories. Example: + +```csharp +public interface IBookStoreMongoDbContext : IAbpMongoDbContext +{ + Collection Books { get; } +} +``` + +`IBookStoreMongoDbContext` is implemented by the `BookStoreMongoDbContext` class. Then you can use generic overload of the `AddDefaultRepositories`: + +```csharp +context.Services.AddMongoDbContext(options => +{ + options.AddDefaultRepositories(); + //... +}); +``` + +Now, your custom `BookRepository` can also use the `IBookStoreMongoDbContext` interface: + +```csharp +public class BookRepository + : MongoDbRepository, + IBookRepository +{ + //... +} +``` + +One advantage of using interface for a MongoDbContext is then it becomes replaceable by another implementation. + +#### Substituir Outros DbContexts + +Once you properly define and use an interface for a MongoDbContext , then any other implementation can use the following ways to replace it: + +**ReplaceDbContextAttribute** + +```csharp +[ReplaceDbContext(typeof(IBookStoreMongoDbContext))] +public class OtherMongoDbContext : AbpMongoDbContext, IBookStoreMongoDbContext +{ + //... +} +``` + +**ReplaceDbContext option** + +```csharp +context.Services.AddMongoDbContext(options => +{ + //... + options.ReplaceDbContext(); +}); +``` + +In this example, `OtherMongoDbContext` implements `IBookStoreMongoDbContext`. This feature allows you to have multiple MongoDbContext (one per module) on development, but single MongoDbContext (implements all interfaces of all MongoDbContexts) on runtime. + +### Personalizar Operações em Massa + +If you have better logic or using an external library for bulk operations, you can override the logic via implementing `IMongoDbBulkOperationProvider`. + +- Você pode usar o modelo de exemplo abaixo: + +```csharp +public class MyCustomMongoDbBulkOperationProvider + : IMongoDbBulkOperationProvider, ITransientDependency +{ + public async Task DeleteManyAsync( + IMongoDbRepository repository, + IEnumerable entities, + IClientSessionHandle sessionHandle, + bool autoSave, + CancellationToken cancellationToken) + where TEntity : class, IEntity + { + // Your logic here. + } + + public async Task InsertManyAsync( + IMongoDbRepository repository, + IEnumerable entities, + IClientSessionHandle sessionHandle, + bool autoSave, + CancellationToken cancellationToken) + where TEntity : class, IEntity + { + // Your logic here. + } + + public async Task UpdateManyAsync( + IMongoDbRepository repository, + IEnumerable entities, + IClientSessionHandle sessionHandle, + bool autoSave, + CancellationToken cancellationToken) + where TEntity : class, IEntity + { + // Your logic here. + } +} +``` + +## Veja Também + +* [Entities](Entities.md) +* [Repositories](Repositories.md) \ No newline at end of file From e6046e55bd048ad2f833334d4813fc1b6a944399 Mon Sep 17 00:00:00 2001 From: "Felipe A. de Almeida" Date: Sat, 26 Jun 2021 16:05:14 -0300 Subject: [PATCH 2/6] #9436 Translation adjustments involving repository --- docs/pt-BR/MongoDB.md | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/docs/pt-BR/MongoDB.md b/docs/pt-BR/MongoDB.md index 08c07c2ad7..a388b1a074 100644 --- a/docs/pt-BR/MongoDB.md +++ b/docs/pt-BR/MongoDB.md @@ -118,9 +118,9 @@ namespace MyCompany.MyProject } ``` -### Adicionar Repositórios Padrão +### Adicionar Repositories Padrão -O ABP pode criar automaticamente [repositórios genéricos](Repositories.md) padrão para as entidades em seu DbContext. Basta usar a opção `AddDefaultRepositories()` no registro: +O ABP pode criar automaticamente [repositories genéricas](Repositories.md) padrão para as entidades em seu DbContext. Basta usar a opção `AddDefaultRepositories()` no registro: ````C# services.AddMongoDbContext(options => @@ -129,7 +129,7 @@ services.AddMongoDbContext(options => }); ```` -Isso criará um repositório para cada [aggregate root entity](Entities.md) (classes derivadas de `AggregateRoot`) por padrão. Se você quiser criar repositórios para outras entidades também, em seguida defina `includeAllEntities` para `true`: +Isso criará uma repository para cada [aggregate root entity](Entities.md) (classes derivadas de `AggregateRoot`) por padrão. Se você quiser criar repositories para outras entidades também, em seguida defina `includeAllEntities` para `true`: ```c# services.AddMongoDbContext(options => @@ -181,11 +181,11 @@ public class BookManager : DomainService Este exemplo usa o método `InsertAsync` para inserir uma nova entity no banco de dados. -### Adicionar Repositórios Personalizados +### Adicionar Repositories Personalizadas -Repositories genéricos padrão são poderosos e suficiente na maioria dos casos (uma vez que implementam `IQueryable`). No entanto, pode ser necessário criar um repositório customizado para adicionar seus próprios métodos de repositório. +Repositories genéricas padrão são poderosas e suficiente na maioria dos casos (uma vez que implementam `IQueryable`). No entanto, pode ser necessário criar uma repository customizada para adicionar seus próprios métodos de repository. -Suponha que você deseja excluir todos os books por type. É sugerido definir uma interface para seu repositório personalizado: +Suponha que você deseja excluir todos os books por type. É sugerido definir uma interface para sua repository personalizada: ```csharp public interface IBookRepository : IRepository @@ -228,9 +228,9 @@ Agora é possível [injetar](Dependency-Injection.md) a `IBookRepository` e usar #### Substituir Repository Genérica Padrão -Mesmo se você criar um repository personalizado, você ainda pode injetar o repository genérico padrão (`IRepository` para este exemplo). A implementação do repository padrão não usará a classe que você criou. +Mesmo se você criar uma repository personalizada, você ainda pode injetar a repository genérica padrão (`IRepository` para este exemplo). A implementação da repository padrão não usará a classe que você criou. -If you want to replace default repository implementation with your custom repository, do it inside `AddMongoDbContext` options: +Se você querer substituir a implementação da repository padrão pela sua repository personalizada, faça dentro das opções `AddMongoDbContext`: ```csharp context.Services.AddMongoDbContext(options => From e78c7665ddee1d858e7e8f0d100c2e2c9cb820cd Mon Sep 17 00:00:00 2001 From: "Felipe A. de Almeida" Date: Sat, 26 Jun 2021 17:04:35 -0300 Subject: [PATCH 3/6] #9436 - Topics, Comments and some Texts --- docs/pt-BR/MongoDB.md | 50 +++++++++++++++++++++---------------------- 1 file changed, 25 insertions(+), 25 deletions(-) diff --git a/docs/pt-BR/MongoDB.md b/docs/pt-BR/MongoDB.md index a388b1a074..ff5d03d621 100644 --- a/docs/pt-BR/MongoDB.md +++ b/docs/pt-BR/MongoDB.md @@ -21,7 +21,7 @@ namespace MyCompany.MyProject [DependsOn(typeof(AbpMongoDbModule))] public class MyModule : AbpModule { - //... + // ... } } ``` @@ -41,7 +41,7 @@ public class MyDbContext : AbpMongoDbContext { base.CreateModel(modelBuilder); - //Personalize a configuração para as suas collections. + // Personalize a configuração para as suas collections. } } ``` @@ -65,8 +65,8 @@ protected override void CreateModel(IMongoModelBuilder modelBuilder) modelBuilder.Entity(b => { - b.CollectionName = "MyQuestions"; //Define o nome da collection - b.BsonMap.UnmapProperty(x => x.MyProperty); //Ignora 'MyProperty' + b.CollectionName = "MyQuestions"; // Define o nome da collection + b.BsonMap.UnmapProperty(x => x.MyProperty); // Ignora 'MyProperty' }); } ```` @@ -76,7 +76,7 @@ Este exemplo altera o nome da collection mapeada para 'MyQuestions' no banco de Se você só precisa configurar o nome da collection, você também pode usar o atributo `[MongoCollection]` para a collection em seu DbContext. Exemplo: ````csharp -[MongoCollection("MyQuestions")] //Define o nome da collection +[MongoCollection("MyQuestions")] // Define o nome da collection public IMongoCollection Questions => Collection(); ```` @@ -112,7 +112,7 @@ namespace MyCompany.MyProject { context.Services.AddMongoDbContext(); - //... + // ... } } } @@ -156,7 +156,7 @@ public class BookManager : DomainService { private readonly IRepository _bookRepository; - public BookManager(IRepository bookRepository) //injetar repositório padrão + public BookManager(IRepository bookRepository) // injetar repositório padrão { _bookRepository = bookRepository; } @@ -172,7 +172,7 @@ public class BookManager : DomainService Type = type }; - await _bookRepository.InsertAsync(book); //Use um método de repositório padrão + await _bookRepository.InsertAsync(book); // Use um método de repositório padrão return book; } @@ -240,7 +240,7 @@ context.Services.AddMongoDbContext(options => }); ``` -This is especially important when you want to **override a base repository method** to customize it. For instance, you may want to override `DeleteAsync` method to delete an entity in a more efficient way: +Isso é especialmente importante quando você deseja dar **override em um método da base repository** para customizar. Por exemplo, você pode querer substituir o método `DeleteAsync` para excluir uma entidade de uma forma mais eficiente: ```csharp public async override Task DeleteAsync( @@ -248,13 +248,13 @@ public async override Task DeleteAsync( bool autoSave = false, CancellationToken cancellationToken = default) { - //TODO: Custom implementation of the delete method + // TODO: Implementação customizada do método delete } ``` -### Access to the MongoDB API +### Acesso à API MongoDB -In most cases, you want to hide MongoDB APIs behind a repository (this is the main purpose of the repository). However, if you want to access the MongoDB API over the repository, you can use `GetDatabaseAsync()`, `GetCollectionAsync()` or `GetAggregateAsync()` extension methods. Example: +Na maioria dos casos, você vai querer ocultar APIs do MongoDB atrás de uma repository (este é o objetivo principal da repository). No entanto, se você quiser acessar a API MongoDB através da Repository, você pode usar os métodos de extensão `GetDatabaseAsync()`, `GetCollectionAsync()` ou `GetAggregateAsync()`. Exemplo: ```csharp public class BookService @@ -292,11 +292,11 @@ Configure(options => ### Tópicos Avançados -### Controlling the Multi-Tenancy +### Controlando o Multi-Tenancy If your solution is [multi-tenant](Multi-Tenancy.md), tenants may have **separate databases**, you have **multiple** `DbContext` classes in your solution and some of your `DbContext` classes should be usable **only from the host side**, it is suggested to add `[IgnoreMultiTenancy]` attribute on your `DbContext` class. In this case, ABP guarantees that the related `DbContext` always uses the host [connection string](Connection-Strings.md), even if you are in a tenant context. -**Example:** +**Exemplo:** ````csharp [IgnoreMultiTenancy] @@ -310,7 +310,7 @@ Do not use the `[IgnoreMultiTenancy]` attribute if any one of your entities in y > When you use repositories, ABP already uses the host database for the entities don't implement the `IMultiTenant` interface. So, most of time you don't need to `[IgnoreMultiTenancy]` attribute if you are using the repositories to work with the database. -#### Set Default Repository Classes +#### Definir Classes Repository Padrão Default generic repositories are implemented by `MongoDbRepository` class by default. You can create your own implementation and use it for default repository implementation. @@ -351,7 +351,7 @@ context.Services.AddMongoDbContext(options => typeof(MyRepositoryBase<,>), typeof(MyRepositoryBase<>) ); - //... + // ... }); ``` @@ -372,7 +372,7 @@ public interface IBookStoreMongoDbContext : IAbpMongoDbContext context.Services.AddMongoDbContext(options => { options.AddDefaultRepositories(); - //... + // ... }); ``` @@ -383,7 +383,7 @@ public class BookRepository : MongoDbRepository, IBookRepository { - //... + // ... } ``` @@ -399,16 +399,16 @@ Once you properly define and use an interface for a MongoDbContext , then any ot [ReplaceDbContext(typeof(IBookStoreMongoDbContext))] public class OtherMongoDbContext : AbpMongoDbContext, IBookStoreMongoDbContext { - //... + // ... } ``` -**ReplaceDbContext option** +**Opção ReplaceDbContext** ```csharp context.Services.AddMongoDbContext(options => { - //... + // ... options.ReplaceDbContext(); }); ``` @@ -417,7 +417,7 @@ In this example, `OtherMongoDbContext` implements `IBookStoreMongoDbContext`. Th ### Personalizar Operações em Massa -If you have better logic or using an external library for bulk operations, you can override the logic via implementing `IMongoDbBulkOperationProvider`. +Se você tiver uma lógica melhor ou usar uma biblioteca externa para operações em massa, pode substituir a lógica por meio da implementação de `IMongoDbBulkOperationProvider`. - Você pode usar o modelo de exemplo abaixo: @@ -433,7 +433,7 @@ public class MyCustomMongoDbBulkOperationProvider CancellationToken cancellationToken) where TEntity : class, IEntity { - // Your logic here. + // Sua lógica aqui. } public async Task InsertManyAsync( @@ -444,7 +444,7 @@ public class MyCustomMongoDbBulkOperationProvider CancellationToken cancellationToken) where TEntity : class, IEntity { - // Your logic here. + // Sua lógica aqui. } public async Task UpdateManyAsync( @@ -455,7 +455,7 @@ public class MyCustomMongoDbBulkOperationProvider CancellationToken cancellationToken) where TEntity : class, IEntity { - // Your logic here. + // Sua lógica aqui. } } ``` From a6a05ce2d15b5ca6474c74096d4d9e47d3225f06 Mon Sep 17 00:00:00 2001 From: "Felipe A. de Almeida" Date: Sat, 26 Jun 2021 19:16:01 -0300 Subject: [PATCH 4/6] #9436 API Transactions and Started Advanced Topics --- docs/pt-BR/MongoDB.md | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/docs/pt-BR/MongoDB.md b/docs/pt-BR/MongoDB.md index ff5d03d621..4d97d8226a 100644 --- a/docs/pt-BR/MongoDB.md +++ b/docs/pt-BR/MongoDB.md @@ -275,11 +275,11 @@ public class BookService } ``` -> Important: You must reference to the `Volo.Abp.MongoDB` package from the project you want to access to the MongoDB API. This breaks encapsulation, but this is what you want in that case. +> Importante: Você deve fazer referência ao pacote `Volo.Abp.MongoDB` do projeto que deseja acessar a API MongoDB. Isso quebra o encapsulamento, mas é o que você deseja nesse caso. ### Transactions -MongoDB supports multi-document transactions starting from the version 4.0 and the ABP Framework supports it. However, the [startup template](Startup-templates/Index.md) **disables** transactions by default. If your MongoDB **server** supports transactions, you can enable the it in the *YourProjectMongoDbModule* class: +O MongoDB oferece suporte multi-document transactions a partir da versão 4.0 e o ABP Framework oferece suporte para isso. No entanto, o [startup template](Startup-templates/Index.md) **desativa** transactions por padrão. Se o seu **servidor** MongoDB suportar transactions, você pode habilitar esse recurso na classe *YourProjectMongoDbModule*: ```csharp Configure(options => @@ -288,13 +288,13 @@ Configure(options => }); ``` -> Or you can delete this code since this is already the default behavior. +> Ou você pode excluir este código, pois este já é o comportamento padrão. ### Tópicos Avançados ### Controlando o Multi-Tenancy -If your solution is [multi-tenant](Multi-Tenancy.md), tenants may have **separate databases**, you have **multiple** `DbContext` classes in your solution and some of your `DbContext` classes should be usable **only from the host side**, it is suggested to add `[IgnoreMultiTenancy]` attribute on your `DbContext` class. In this case, ABP guarantees that the related `DbContext` always uses the host [connection string](Connection-Strings.md), even if you are in a tenant context. +Se sua solução for [multi-tenant](Multi-Tenancy.md), os tenants podem ter **bancos de dados separados**, você tem **múltiplas** classes `DbContext` em sua solução e algumas de suas classes `DbContext` devem ser utilizáveis **apenas do lado do host**, é recomendado adicionar o atributo `[IgnoreMultiTenancy]` em sua classe `DbContext`. Nesse caso, a ABP garante que o `DbContext` relacionado sempre usa a [connection string](Connection-Strings.md) do host, mesmo se você estiver em um tenant context. **Exemplo:** @@ -306,7 +306,7 @@ public class MyDbContext : AbpMongoDbContext } ```` -Do not use the `[IgnoreMultiTenancy]` attribute if any one of your entities in your `DbContext` can be persisted in a tenant database. +Não use o atributo `[IgnoreMultiTenancy]` se qualquer uma de suas entidades em seu `DbContext` puder ser persistida em um outro banco de dados de um tenant. > When you use repositories, ABP already uses the host database for the entities don't implement the `IMultiTenant` interface. So, most of time you don't need to `[IgnoreMultiTenancy]` attribute if you are using the repositories to work with the database. From 08243038ad45e65aee28d76fcd2bbeee01a9a06c Mon Sep 17 00:00:00 2001 From: "Felipe A. de Almeida" Date: Mon, 28 Jun 2021 08:52:31 -0300 Subject: [PATCH 5/6] #9436 - Translation finished --- docs/pt-BR/MongoDB.md | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/docs/pt-BR/MongoDB.md b/docs/pt-BR/MongoDB.md index 4d97d8226a..2f10fae7c8 100644 --- a/docs/pt-BR/MongoDB.md +++ b/docs/pt-BR/MongoDB.md @@ -312,9 +312,9 @@ Não use o atributo `[IgnoreMultiTenancy]` se qualquer uma de suas entidades em #### Definir Classes Repository Padrão -Default generic repositories are implemented by `MongoDbRepository` class by default. You can create your own implementation and use it for default repository implementation. +Repositories genéricas padrão são implementados pela classe `MongoDbRepository` por padrão. Você pode criar sua própria implementação e usá-la para implementação da repository padrão. -First, define your repository classes like that: +Primeiro, defina suas classes de repository assim: ```csharp public class MyRepositoryBase @@ -338,11 +338,11 @@ public class MyRepositoryBase } ``` -First one is for [entities with composite keys](Entities.md), second one is for entities with single primary key. +O primeiro é para [entities com chaves compostas](Entities.md), o segundo é para entities com uma única chave primária. -It's suggested to inherit from the `MongoDbRepository` class and override methods if needed. Otherwise, you will have to implement all standard repository methods manually. +É sugerido herdar da classe `MongoDbRepository` e substituir os métodos, se necessário. Caso contrário, você terá que implementar todos os métodos de repository padrão manualmente. -Now, you can use `SetDefaultRepositoryClasses` option: +Agora, você pode usar a opção `SetDefaultRepositoryClasses`: ```csharp context.Services.AddMongoDbContext(options => @@ -357,7 +357,7 @@ context.Services.AddMongoDbContext(options => #### Definir classe base MongoDbContext ou Interface para Repositories padrão -If your MongoDbContext inherits from another MongoDbContext or implements an interface, you can use that base class or interface as the MongoDbContext for default repositories. Example: +Se seu MongoDbContext herda de outro MongoDbContext ou implementa uma interface, você pode usar essa classe base ou interface como o MongoDbContext para repositories padrão. Exemplo: ```csharp public interface IBookStoreMongoDbContext : IAbpMongoDbContext @@ -366,7 +366,7 @@ public interface IBookStoreMongoDbContext : IAbpMongoDbContext } ``` -`IBookStoreMongoDbContext` is implemented by the `BookStoreMongoDbContext` class. Then you can use generic overload of the `AddDefaultRepositories`: +`IBookStoreMongoDbContext` é implementado pela classe `BookStoreMongoDbContext`. Então você pode usar sobrecarga genérica do `AddDefaultRepositories`: ```csharp context.Services.AddMongoDbContext(options => @@ -376,7 +376,7 @@ context.Services.AddMongoDbContext(options => }); ``` -Now, your custom `BookRepository` can also use the `IBookStoreMongoDbContext` interface: +Agora, seu `BookRepository` personalizado também pode usar a interface `IBookStoreMongoDbContext`: ```csharp public class BookRepository @@ -387,11 +387,11 @@ public class BookRepository } ``` -One advantage of using interface for a MongoDbContext is then it becomes replaceable by another implementation. +Uma vantagem de usar a interface para um MongoDbContext é que ela pode ser substituída por outra implementação. #### Substituir Outros DbContexts -Once you properly define and use an interface for a MongoDbContext , then any other implementation can use the following ways to replace it: +Depois de definir e usar adequadamente uma interface para um MongoDbContext, qualquer outra implementação pode usar as seguintes maneiras de substituí-lo: **ReplaceDbContextAttribute** @@ -413,7 +413,7 @@ context.Services.AddMongoDbContext(options => }); ``` -In this example, `OtherMongoDbContext` implements `IBookStoreMongoDbContext`. This feature allows you to have multiple MongoDbContext (one per module) on development, but single MongoDbContext (implements all interfaces of all MongoDbContexts) on runtime. +Neste exemplo, `OtherMongoDbContext` implementa `IBookStoreMongoDbContext`. Este recurso permite que você tenha vários MongoDbContext (um por módulo) no desenvolvimento, mas um único MongoDbContext (implementa todas as interfaces de todos os MongoDbContexts) no tempo de execução. ### Personalizar Operações em Massa From fa9af477d5f91fa2996d5622e97cb3d1ce2a3293 Mon Sep 17 00:00:00 2001 From: "Felipe A. de Almeida" Date: Mon, 28 Jun 2021 08:57:12 -0300 Subject: [PATCH 6/6] #9436 - Phrase Adjustment --- docs/pt-BR/MongoDB.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/pt-BR/MongoDB.md b/docs/pt-BR/MongoDB.md index 2f10fae7c8..bc4a7882a7 100644 --- a/docs/pt-BR/MongoDB.md +++ b/docs/pt-BR/MongoDB.md @@ -312,7 +312,7 @@ Não use o atributo `[IgnoreMultiTenancy]` se qualquer uma de suas entidades em #### Definir Classes Repository Padrão -Repositories genéricas padrão são implementados pela classe `MongoDbRepository` por padrão. Você pode criar sua própria implementação e usá-la para implementação da repository padrão. +Repositories genéricas padrão são implementadas pela classe `MongoDbRepository` por padrão. Você pode criar sua própria implementação e usá-la para implementação da repository padrão. Primeiro, defina suas classes de repository assim: