diff --git a/abp_io/AbpIoLocalization/AbpIoLocalization/Commercial/Localization/Resources/en.json b/abp_io/AbpIoLocalization/AbpIoLocalization/Commercial/Localization/Resources/en.json index f38f7d92dc..8a0e47c529 100644 --- a/abp_io/AbpIoLocalization/AbpIoLocalization/Commercial/Localization/Resources/en.json +++ b/abp_io/AbpIoLocalization/AbpIoLocalization/Commercial/Localization/Resources/en.json @@ -210,7 +210,7 @@ "TrialPlan": "Do you have a trial plan?", "TrialPlanExplanation": "It has a 14 days trial period for the ABP Commercial team license. For more information visit here. Furthermore, for the Team licenses we provide a 30 days money-back guarantee. You can just request a refund in the first 30 days. For the Business and Enterprise licenses, we provide 60% refund in 30 days. This is because Business and Enterprise licenses include the full source code of all the modules and the themes.", "DoYouAcceptBankWireTransfer": "Do you accept bank wire transfers?", - "DoYouAcceptBankWireTransferExplanation": "Yes, we accept bank wire transfers.
After sending the license fee via bank transfer, send your receipt and requested license type to accounting@abp.io.
Our international bank account information:", + "DoYouAcceptBankWireTransferExplanation": "Yes, we accept bank wire transfers.
After sending the license fee via bank transfer, send your receipt and requested license type to accounting@volosoft.com.
Our international bank account information:", "HowToUpgrade": "How to upgrade existing applications when a new version is available?", "HowToUpgradeExplanation1": "When you create a new application using ABP Commercial, all the modules and theme are used as NuGet and NPM packages. So, you can easily upgrade the packages when a new version is available.", "HowToUpgradeExplanation2": "In addition to the standard NuGet/NPM upgrades, ABP CLI provides an update command that automatically finds and upgrades all ABP related packages in your solution.", diff --git a/docs/en/Community-Articles/2022-11-25-JSON-columns/Database.png b/docs/en/Community-Articles/2022-11-25-JSON-columns/Database.png new file mode 100644 index 0000000000..c8a5516aa6 Binary files /dev/null and b/docs/en/Community-Articles/2022-11-25-JSON-columns/Database.png differ diff --git a/docs/en/Community-Articles/2022-11-25-JSON-columns/post.md b/docs/en/Community-Articles/2022-11-25-JSON-columns/post.md new file mode 100644 index 0000000000..cb8ceafc88 --- /dev/null +++ b/docs/en/Community-Articles/2022-11-25-JSON-columns/post.md @@ -0,0 +1,131 @@ +# JSON Columns in Entity Framework Core 7 + +In this article, we will see how to use the new **JSON Columns** features that came with EF Core 7 in an ABP based application (with examples). + +## JSON Columns + +Most relational databases support columns that contain JSON documents. The JSON in these columns can be drilled into with queries. This allows, for example, filtering and sorting by the elements of the documents, as well as projection of elements out of the documents into results. JSON columns allow relational databases to take on some of the characteristics of document databases, creating a useful hybrid between these two database management approaches. + +EF7 contains provider-agnostic support for JSON columns, with an implementation for SQL Server. This support allows the mapping of aggregates built from .NET types to JSON documents. Normal LINQ queries can be used on the aggregates, and these will be translated to the appropriate query constructs needed to drill into the JSON. EF7 also supports updating and saving changes to JSON documents. + +> You can find more information about JSON columns in EF Core's [documentation](https://docs.microsoft.com/en-us/ef/core/what-is-new/ef-core-7.0/whatsnew#json-columns). + +### Mapping JSON Columns + +In EF Core, aggregate types can be defined using `OwnsOne` and `OwnsMany` methods. `OwnsOne` can be used to map a single aggregate and the `OwnsMany` method can be used to map a collection of aggregates. + +With EF 7, we have a new extension method for mapping property to a JSON Column: `ToJson`. We can use this method to mark a property as a JSON Column. The property can be of any type that can be serialized to JSON. + +The following example shows how to map a JSON column to an aggregate type: + +```csharp +public class ContactDetails +{ + public Address Address { get; set; } + public string? Phone { get; set; } +} + +public class Address +{ + public Address(string street, string city, string postcode, string country) + { + Street = street; + City = city; + Postcode = postcode; + Country = country; + } + + public string Street { get; set; } + public string City { get; set; } + public string Postcode { get; set; } + public string Country { get; set; } +} + +public class Person : AggregateRoot +{ + public string Name { get; set; } = null!; + public ContactDetails ContactDetails { get; set; } = null!; +} +``` + +* Above, we have defined an aggregate type `ContactDetails` that contains an `Address` and a `Phone` number. The aggregate type is configured in `OnModelCreating` using `OwnsOne` and `ToJson` methods below. +* The `Address` property is mapped to a JSON column using `ToJson`, and the `Phone` property is mapped to a regular column. This requires just one call to **ToJson()** when configuring the aggregate type: + +```csharp + +public class MyDbContext : AbpDbContext +{ + public DbSet Persons { get; set; } + + public MyDbContext(DbContextOptions options) + : base(options) + { + } + + protected override void OnModelCreating(ModelBuilder builder) + { + base.OnModelCreating(builder); + + builder.Entity(b => + { + b.ToTable(MyProjectConsts.DbTablePrefix + "Persons", MyProjecConsts.DbSchema); + b.ConfigureByConvention(); + b.OwnsOne(x=>x.ContactDetails, c => + { + c.ToJson(); //mark as JSON Column + c.OwnsOne(cd => cd.Address); + }); + }); + } +} +``` + +### Querying JSON Columns + +Queries into JSON columns work just the same as querying into any other aggregate type in EF Core. That's it, just use the LINQ! Here are some examples: + +```csharp +var persons = await (await GetDbSetAsync()).ToListAsync(); + +var contacts = await (await GetDbSetAsync()).Select(person => new +{ + person, + person.ContactDetails.Phone, //query over JSON column + Addresses = person.ContactDetails.Address //query over JSON column +}).ToListAsync(); + +var addresses = await (await GetDbSetAsync()).Select(person => new +{ + person, + Addresses = person.ContactDetails.Address //query over JSON column +}).ToListAsync(); +``` + +### Updating JSON Columns + +You can update JSON columns the same as updating any record by using the `UpdateAsync` method. The following example shows how to update a JSON column: + +```csharp +var person = await (await GetDbSetAsync()).FirstAsync(); + +person.ContactDetails.Phone = "123456789"; +person.ContactDetails.Address = new Address("Street", "City", "Postcode", "Country"); +await UpdateAsync(person, true); +``` + +### JSON Column in a Database + +After you've configured the database relations, created a new migration and applied it to database you will have a database table like below: + +![image](./Database.png) + +As you can see, thanks to JSON Columns feature the **ContactDetails** row has JSON content and we can use it in a query or update it from our application with the LINQ JSON query support that mentioned above. + +### Conclusion + +In this article, I've briefly introduced the JSON Columns feature that was shipped with EF Core 7. It's pretty straightforward to use JSON Columns in an ABP based application. You can see the examples above and give it a try! + +### References + +* [https://docs.microsoft.com/en-us/ef/core/what-is-new/ef-core-7.0/whatsnew#json-columns](https://docs.microsoft.com/en-us/ef/core/what-is-new/ef-core-7.0/whatsnew#json-columns) +* [https://docs.microsoft.com/en-us/ef/core/modeling/owned-entities](https://docs.microsoft.com/en-us/ef/core/modeling/owned-entities) \ No newline at end of file diff --git a/docs/en/Community-Articles/2022-11-27-gRPC-Health-Checks/POST.md b/docs/en/Community-Articles/2022-11-27-gRPC-Health-Checks/POST.md new file mode 100644 index 0000000000..70bcb15e38 --- /dev/null +++ b/docs/en/Community-Articles/2022-11-27-gRPC-Health-Checks/POST.md @@ -0,0 +1,73 @@ +# gRPC - Health Checks + +In this article we will show how to use gRPC health checks with the ABP Framework. + +## Health Checks + +ASP.NET Core 7 supports gRPC health checks. Health Checks allow us to determine the overall health and availability of our application infrastructure. They are exposed as HTTP endpoints and can be configured to provide information for various monitoring scenarios, such as the response time and memory usage of our application, or whether our application can communicate with our database provider. + +### gRPC Health Checks + +The [gRPC health checking protocol](https://github.com/grpc/grpc/blob/master/doc/health-checking.md) is a standard for reporting the health of gRPC server apps. An app exposes health checks as a gRPC service. They are typically used with an external monitoring service to check the status of an app. + +### Grpc.AspNetCore.HealthChecks + +ASP.NET Core supports the gRPC health checking protocol with the [Grpc.AspNetCore.HealthChecks](https://www.nuget.org/packages/Grpc.AspNetCore.HealthChecks) package. Results from .NET health checks are reported to callers. + +## Using gRPC Health Checks with the ABP Framework + +In this article, I'm assuming you've used gRPC with ABP before. If you are still having problems with this, it may be good for you to review this article. +https://community.abp.io/posts/using-grpc-with-the-abp-framework-2dgaxzw3 + +### Set up gRPC Health Checks + +In this solution, `*.HttpApi.Host` is the project that configures and runs the server-side application. So, we will make changes in that project. + +* Add the `Grpc.AspNetCore.HealthChecks` package to your project. + +```bash +dotnet add package Grpc.AspNetCore.HealthChecks +``` + +* `AddGrpcHealthChecks` to register services that enable health checks. + +```csharp +public override void ConfigureServices(ServiceConfigurationContext context) +{ + // Other configurations... + + context.Services.AddGrpcHealthChecks() + .AddCheck("SampleHealthCheck", () => HealthCheckResult.Healthy()); +} +``` +* `MapGrpcHealthChecksService` to add a health check service endpoint. + +```csharp +public override void OnApplicationInitialization(ApplicationInitializationContext context) +{ + // Other middlewares... + + app.UseConfiguredEndpoints(builder => + { + builder.MapGrpcHealthChecksService(); + }); +} +``` + +### Calling Health Checks From a Client + +Now that our server is configured for gRPC health checks, we can test it by creating a basic console client. + +```csharp +var channel = GrpcChannel.ForAddress("https://localhost:44357"); +var client = new Health.HealthClient(channel); + +var response = await client.CheckAsync(new HealthCheckRequest()); +var status = response.Status; + +Console.WriteLine($"Health Status: {status}"); +``` + +## References + +- https://learn.microsoft.com/en-us/aspnet/core/release-notes/aspnetcore-7.0?view=aspnetcore-7.0#grpc-health-checks-in-aspnet-core diff --git a/docs/en/Community-Articles/2022-11-28-EF-Core-Entity-Dependency-Injection/POST.md b/docs/en/Community-Articles/2022-11-28-EF-Core-Entity-Dependency-Injection/POST.md new file mode 100644 index 0000000000..8ed92d43c2 --- /dev/null +++ b/docs/en/Community-Articles/2022-11-28-EF-Core-Entity-Dependency-Injection/POST.md @@ -0,0 +1,381 @@ +# Injecting Service Dependencies to Entities with Entity Framework Core 7.0 + +[Dependency injection](https://docs.abp.io/en/abp/latest/Dependency-Injection) is a widely-used pattern of obtaining references to other services from our classes. It is a built-in feature when you develop ASP.NET Core applications. In this article, I will explain why we may need to have references to other services in an entity class and how we can implement Entity Framework Core's new `IMaterializationInterceptor` interface to provide these services to the entities using the standard dependency injection system. + +> You can find the source code of the example application [here](https://github.com/abpframework/abp-samples/tree/master/EfCoreEntityDependencyInjectionDemo). + +## The Problem + +While developing applications based on [Domain-Driven Design](https://docs.abp.io/en/abp/latest/Domain-Driven-Design) (DDD) patterns, we typically write our business code inside [application services](https://docs.abp.io/en/abp/latest/Application-Services), [domain services](https://docs.abp.io/en/abp/latest/Domain-Services) and [entities](https://docs.abp.io/en/abp/latest/Entities). Since the application and domain service instances are created by the dependency injection system, they can inject services into their constructors. + +Here, an example domain service that injects a repository into its constructor: + +````csharp +public class ProductManager : DomainService +{ + private readonly IRepository _productRepository; + + public ProductManager(IRepository productRepository) + { + _productRepository = productRepository; + } + + //... +} +```` + +`ProductManager` can then use the `_productRepository` object in its methods to perform its business logic. In the following example, `ChangeCodeAsync` method is used to change a product's code (the `ProductCode` property) by ensuring uniqueness of product codes in the system: + +````csharp +public class ProductManager : DomainService +{ + private readonly IRepository _productRepository; + + public ProductManager(IRepository productRepository) + { + _productRepository = productRepository; + } + + public async Task ChangeCodeAsync(Product product, string newProductCode) + { + Check.NotNull(product, nameof(product)); + Check.NotNullOrWhiteSpace(newProductCode, nameof(newProductCode)); + + if (product.ProductCode == newProductCode) + { + return; + } + + if (await _productRepository.AnyAsync(x => x.ProductCode == newProductCode)) + { + throw new ApplicationException( + "Product code is already used: " + newProductCode); + } + + product.ProductCode = newProductCode; + } +} +```` + +Here, the `ProductManager` forces the rule "product code must be unique". Let's see the `Product` entity class too: + +````csharp +public class Product : AuditedAggregateRoot +{ + public string ProductCode { get; internal set; } + + public string Name { get; private set; } + + private Product() + { + /* This constructor is used by EF Core while + getting the Product from database */ + } + + /* Primary constructor that should be used in the application code */ + public Product(string productCode, string name) + { + ProductCode = Check.NotNullOrWhiteSpace(productCode, nameof(productCode)); + Name = Check.NotNullOrWhiteSpace(name, nameof(name)); + } +} +```` + +You see that the `ProductCode` property's setter is `internal`, which makes possible to set it from the `ProductManager` class as shown before. + +This design has a problem: We had to make the `ProductCode` setter `internal`. Now, any developer may forget to use the `ProductManager.ChangeCodeAsync` method, and can directly set the `ProductCode` on the entity. So, we can't completely force the "product code must be unique" rule. + +It would be better to move the `ChangeCodeAsync` method into the `Product` class and make the `ProductCode` property's setter `private`: + +````csharp +public class Product : AuditedAggregateRoot +{ + public string ProductCode { get; private set; } + + public string Name { get; private set; } + + // ... + + public async Task ChangeCodeAsync(string newProductCode) + { + Check.NotNullOrWhiteSpace(newProductCode, nameof(newProductCode)); + + if (newProductCode == ProductCode) + { + return; + } + + /* ??? HOW TO INJECT THE PRODUCT REPOSITORY HERE ??? */ + if (await _productRepository.AnyAsync(x => x.ProductCode == newProductCode)) + { + throw new ApplicationException("Product code is already used: " + newProductCode); + } + + ProductCode = newProductCode; + } +} +```` + +With that design, there is no way to set the `ProductCode` without applying the rule "product code must be unique". Great! But we have a problem: An entity class can not inject dependencies into its constructor, because an entity is not created using the dependency injection system. There are two common points of creating an entity: + +* We can create an entity in our application code, using the standard `new` keyword, like `var product = new Product(...);`. +* Entity Framework (and any other ORM / database provider) creates entities after getting them from the database. They typically use the empty (default) constructor of the entity to create it, then sets the properties coming from the database query. + +So, how we can use the product repository in the `Product.ChangeCodeAsync` method? If we forget the dependency injection system, we would think to add the repository as a parameter to the `ChangeCodeAsync` method and delegate the responsibility of obtaining the service reference to the caller of that method: + +````csharp +public async Task ChangeCodeAsync( + IRepository productRepository, string newProductCode) +{ + Check.NotNull(productRepository, nameof(productRepository)); + Check.NotNullOrWhiteSpace(newProductCode, nameof(newProductCode)); + + if (newProductCode == ProductCode) + { + return; + } + + if (await productRepository.AnyAsync(x => x.ProductCode == newProductCode)) + { + throw new ApplicationException( + "Product code is already used: " + newProductCode); + } + + ProductCode = newProductCode; +} +```` + +However, that design would make hard to use the `ChangeCodeAsync` method, and also exposes its internal dependencies to outside. If we need another dependency in the `ChangeCodeAsync` method later, we should add another parameter, which will effect all the application code that uses the `ChangeCodeAsync` method. I think that's not reasonable. The next section offers a better and a more generic solution to the problem. + +## The Solution + +First of all, we can introduce an interface that should be implemented by the entity classes which needs to use services in their methods: + +````csharp +public interface IInjectServiceProvider +{ + ICachedServiceProvider ServiceProvider { get; set; } +} +```` + +`ICachedServiceProvider` is a service that is provided by the ABP Framework. It extends the standard `IServiceProvider`, but caches the resolved services. Basically, it internally resolves a service only a single time, even if you resolve the service from it multiple times. The `ICachedServiceProvider` service itself is a scoped service, means it is created only once in a scope. We can use it to optimize the service resolution, however, the standard `IServiceProvider` would work as expected. + +Next, we can implement the `IInjectServiceProvider` for our `Product` entity: + +````csharp +public class Product : AuditedAggregateRoot, IInjectServiceProvider +{ + public ICachedServiceProvider ServiceProvider { get; set; } + + //... +} +```` + +I will explain how to set the `ServiceProvider` property later, but first see how to use it in our `Product.ChangeCodeAsync` method. Here, the final `Product` class: + +````csharp +public class Product : AuditedAggregateRoot, IInjectServiceProvider +{ + public string ProductCode { get; internal set; } + + public string Name { get; private set; } + + public ICachedServiceProvider ServiceProvider { get; set; } + + private Product() + { + /* This constructor is used by EF Core while + getting the Product from database */ + } + + /* Primary constructor that should be used in the application code */ + public Product(string productCode, string name) + { + ProductCode = Check.NotNullOrWhiteSpace(productCode, nameof(productCode)); + Name = Check.NotNullOrWhiteSpace(name, nameof(name)); + } + + public async Task ChangeCodeAsync(string newProductCode) + { + Check.NotNullOrWhiteSpace(newProductCode, nameof(newProductCode)); + + if (newProductCode == ProductCode) + { + return; + } + + var productRepository = ServiceProvider + .GetRequiredService>(); + + if (await productRepository.AnyAsync(x => x.ProductCode == newProductCode)) + { + throw new ApplicationException("Product code is already used: " + newProductCode); + } + + ProductCode = newProductCode; + } +} +```` + +The `ChangeCodeAsync` method gets the product repository from the `ServiceProvider` and uses it to check if there is another product with the given `newProductCode` value. + +Now, let's explain how to set the `ServiceProvider` value... + +### Entity Framework Core Configuration + +Entity Framework 7.0 introduces the `IMaterializationInterceptor` interceptor that allows us to manipulate an entity object just after the entity object is created as a result of database query. + +We can write the following interceptor that sets the `ServiceProvider` property of an entity, if it implements the `IInjectServiceProvider` interface: + +````csharp +public class ServiceProviderInterceptor : IMaterializationInterceptor +{ + public object InitializedInstance( + MaterializationInterceptionData materializationData, + object instance) + { + if (instance is IInjectServiceProvider entity) + { + entity.ServiceProvider = materializationData + .Context + .GetService(); + } + + return instance; + } +} +```` + +> Lifetime of the resolved services are tied to the lifetime of the related `DbContext` instance. So, you don't need to care if the resolved dependencies are disposed. ABP's [unit of work](https://docs.abp.io/en/abp/latest/Unit-Of-Work) system already disposes the `DbContext` instance when the unit of work is completed. + +Once we defined such an interceptor, we should configure our `DbContext` class to use it. You can do it by overriding the `OnConfiguring` method in your `DbContext` class: + +````csharp +protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder) +{ + base.OnConfiguring(optionsBuilder); + optionsBuilder.AddInterceptors(new ServiceProviderInterceptor()); +} +```` + +Finally, you should ignore the `ServiceProvider` property in your entity mapping configuration in your `DbContext` (because we don't want to map it to a database table field): + +````csharp +protected override void OnModelCreating(ModelBuilder builder) +{ + base.OnModelCreating(builder); + // ... + builder.Entity(b => + { + // ... + /* We should ignore the ServiceProvider on mapping! */ + b.Ignore(x => x.ServiceProvider); + }); +} +```` + +That's all. From now, EF Core will set the `ServiceProvider` property for you. + +### Manually Creating Entities + +While EF Core seamlessly set the `ServiceProvider` property while getting entities from database, you should still set it manually while creating new entities yourself. + +**Example: Set `ServiceProvider` property while creating a new Product entity:** + +````csharp +public async Task CreateAsync(CreateProductDto input) +{ + var product = new Product(input.ProductCode, input.Name) + { + ServiceProvider = _cachedServiceProvider + }; + + await _productRepository.InsertAsync(product); +} +```` + +Here, you may think that it is not necessary to set the `ServiceProvider`, because we haven't used the `ChangeCodeAsync` method. You are definitely right; It is not needed in this example, because it is clear to see the entity object is not used between the entity creation and saving it to the database. However, if you call a method of the entity, or pass it to another service before inserting into the database, you may not know if the `ServiceProvider` will be needed. So, you should carefully use it. + +Basically, I've introduced the problem and the solution. In the next section, I will explain some limitations of that design and some of my other thoughts. + +## Discussions + +In this section, I will first discuss a slightly different way of obtaining services. Then I will explain limitations and problems of injecting services into entities. + +### Why injected a service provider, but not the services? + +As an obvious question, you may ask why we've property-injected a service provider object, then resolved the services manually. Can't we directly property-inject our dependencies? + +**Example: Property-inject the `IRepository` service:** + +````csharp +public class Product : AuditedAggregateRoot +{ + // ... + + public IRepository ProductRepository { get; set; } + + public async Task ChangeCodeAsync(string newProductCode) + { + Check.NotNullOrWhiteSpace(newProductCode, nameof(newProductCode)); + + if (newProductCode == ProductCode) + { + return; + } + + if (await ProductRepository.AnyAsync(x => x.ProductCode == newProductCode)) + { + throw new ApplicationException("Product code is already used: " + newProductCode); + } + + ProductCode = newProductCode; + } +} +```` + +Now, we don't need to implement the `IInjectServiceProvider` interface and manually resolve the `IRepository` object from the `ServiceProvider`. You see that the `ChangeCodeAsync` method is much simpler now. + +So, how to set `ProductRepository`? For the EF Core interceptor part, you can somehow get all public properties of the entity via reflection. Then, for each property, check if such a service does exist, and set it from the dependency injection system if available. Surely, that will be less performant, but will work if you can truly implement. On the other hand, it would be extra hard to set all the dependencies of the entity while manually creating it using the `new` keyword. So, personally I wouldn't recommend that approach. + +### Limitations + +One important limitation is that you can not use the services inside your entity's constructor code. Ideally, the constructor of the `Product` class should check if the product code is already used before. See the following constructor: + +````csharp +public Product(string productCode, string name) +{ + ProductCode = Check.NotNullOrWhiteSpace(productCode, nameof(productCode)); + Name = Check.NotNullOrWhiteSpace(name, nameof(name)); + + /* Can not check if product code is already used by another product? */ +} +```` + +It is not possible to use the product repository here, because; + +1. The services are property-injected. That means they will be set after the object creation has completed. +2. Even if the service is available, it won't be truly possible to call async code in a constructor. You know constructors can not be async in C#, but the repository and other service methods are generally designed as async. + +So, if you want to force the "product code must be unique" rule, you should create an async domain service method (like `ProductManager.CreateAsync(...)`) and always use it to create products (you can make the `Product` class constructor `internal` to not allow to use it in the application layer). + +### Design Problems + +Beside the technical limitations, coupling your entities to external services is generally considered as a bad design. It makes your entities over-complicated, hard to test, and generally leads to take too much responsibility over the time. + +## Conclusion + +In this article, I tried to investigate all aspects of injecting services into entity classes. I explained how to use Entity Framework 7.0 `IMaterializationInterceptor` to implement property-injection pattern while getting entities from database. + +Injecting services into entities seems a certain way of forcing some business rules in your entities. However, because of the current technical limitations, design issues and usage difficulties, I don't suggest to depend on services in your entities. Instead, create domain services when you need to implement a business rule that depends on external services and entities. + +## The Source Code + +* You can find the full source code of the example application [here](https://github.com/abpframework/abp-samples/tree/master/EfCoreEntityDependencyInjectionDemo). +* You can see [this pull request](https://github.com/abpframework/abp-samples/pull/207/files) for the changes I've done after creating the application. + +## See Also + +* [What's new in EF Core 7.0](https://learn.microsoft.com/en-us/ef/core/what-is-new/ef-core-7.0/whatsnew) +* [ABP Framework: Dependency Injection](https://docs.abp.io/en/abp/latest/Dependency-Injection) +* [ABP Framework: Domain Driven Design](https://docs.abp.io/en/abp/latest/Domain-Driven-Design) \ No newline at end of file diff --git a/docs/en/UI/Angular/Extensions-Overall.md b/docs/en/UI/Angular/Extensions-Overall.md index 8f7b697e59..2bb9862b1d 100644 --- a/docs/en/UI/Angular/Extensions-Overall.md +++ b/docs/en/UI/Angular/Extensions-Overall.md @@ -11,7 +11,7 @@ See the documents below for the details: ## Extensible Table Component -Using [ngx-datatable](https://github.com/swimlane/ngx-datatable) in extensinble table. +Using [ngx-datatable](https://github.com/swimlane/ngx-datatable) in extensible table. ````ts - - - - + + + + diff --git a/framework/src/Volo.Abp.Cli.Core/Volo/Abp/Cli/ProjectBuilding/AbpIoSourceCodeStore.cs b/framework/src/Volo.Abp.Cli.Core/Volo/Abp/Cli/ProjectBuilding/AbpIoSourceCodeStore.cs index e0817d8a45..7dceb70337 100644 --- a/framework/src/Volo.Abp.Cli.Core/Volo/Abp/Cli/ProjectBuilding/AbpIoSourceCodeStore.cs +++ b/framework/src/Volo.Abp.Cli.Core/Volo/Abp/Cli/ProjectBuilding/AbpIoSourceCodeStore.cs @@ -261,6 +261,12 @@ public class AbpIoSourceCodeStore : ISourceCodeStore, ITransientDependency } catch (Exception ex) { + if(ex is UserFriendlyException) + { + Logger.LogWarning(ex.Message); + throw; + } + Console.WriteLine("Error occured while downloading source-code from {0} : {1}{2}{3}", url, responseMessage?.ToString(), Environment.NewLine, ex.Message); throw; diff --git a/modules/feature-management/src/Volo.Abp.FeatureManagement.Blazor/AbpFeatureManagementBlazorModule.cs b/modules/feature-management/src/Volo.Abp.FeatureManagement.Blazor/AbpFeatureManagementBlazorModule.cs index 87882015fc..0e3969fccd 100644 --- a/modules/feature-management/src/Volo.Abp.FeatureManagement.Blazor/AbpFeatureManagementBlazorModule.cs +++ b/modules/feature-management/src/Volo.Abp.FeatureManagement.Blazor/AbpFeatureManagementBlazorModule.cs @@ -1,6 +1,9 @@ -using Volo.Abp.AspNetCore.Components.Web.Theming; +using Localization.Resources.AbpUi; +using Volo.Abp.AspNetCore.Components.Web.Theming; using Volo.Abp.FeatureManagement.Blazor.Settings; +using Volo.Abp.FeatureManagement.Localization; using Volo.Abp.Features; +using Volo.Abp.Localization; using Volo.Abp.Modularity; using Volo.Abp.SettingManagement.Blazor; @@ -20,5 +23,12 @@ public class AbpFeatureManagementBlazorModule : AbpModule { options.Contributors.Add(new FeatureSettingManagementComponentContributor()); }); + + Configure(options => + { + options.Resources + .Get() + .AddBaseTypes(typeof(AbpUiResource)); + }); } } diff --git a/modules/identity/src/Volo.Abp.Identity.Blazor/AbpIdentityBlazorModule.cs b/modules/identity/src/Volo.Abp.Identity.Blazor/AbpIdentityBlazorModule.cs index 4b9dc5326f..3367b42a1b 100644 --- a/modules/identity/src/Volo.Abp.Identity.Blazor/AbpIdentityBlazorModule.cs +++ b/modules/identity/src/Volo.Abp.Identity.Blazor/AbpIdentityBlazorModule.cs @@ -1,7 +1,10 @@ -using Microsoft.Extensions.DependencyInjection; +using Localization.Resources.AbpUi; +using Microsoft.Extensions.DependencyInjection; using Volo.Abp.AspNetCore.Components.Web.Theming.Routing; using Volo.Abp.AutoMapper; using Volo.Abp.BlazoriseUI; +using Volo.Abp.Identity.Localization; +using Volo.Abp.Localization; using Volo.Abp.Modularity; using Volo.Abp.ObjectExtending; using Volo.Abp.ObjectExtending.Modularity; @@ -39,6 +42,15 @@ public class AbpIdentityBlazorModule : AbpModule { options.AdditionalAssemblies.Add(typeof(AbpIdentityBlazorModule).Assembly); }); + + Configure(options => + { + options.Resources + .Get() + .AddBaseTypes( + typeof(AbpUiResource) + ); + }); } public override void PostConfigureServices(ServiceConfigurationContext context) diff --git a/modules/permission-management/src/Volo.Abp.PermissionManagement.Blazor/AbpPermissionManagementBlazorModule.cs b/modules/permission-management/src/Volo.Abp.PermissionManagement.Blazor/AbpPermissionManagementBlazorModule.cs index fbcb7f26a1..1e7e69d4c3 100644 --- a/modules/permission-management/src/Volo.Abp.PermissionManagement.Blazor/AbpPermissionManagementBlazorModule.cs +++ b/modules/permission-management/src/Volo.Abp.PermissionManagement.Blazor/AbpPermissionManagementBlazorModule.cs @@ -1,6 +1,9 @@ -using Volo.Abp.AspNetCore.Components.Web.Theming; +using Localization.Resources.AbpUi; +using Volo.Abp.AspNetCore.Components.Web.Theming; using Volo.Abp.AutoMapper; +using Volo.Abp.Localization; using Volo.Abp.Modularity; +using Volo.Abp.PermissionManagement.Localization; namespace Volo.Abp.PermissionManagement.Blazor; @@ -11,5 +14,15 @@ namespace Volo.Abp.PermissionManagement.Blazor; )] public class AbpPermissionManagementBlazorModule : AbpModule { - + public override void ConfigureServices(ServiceConfigurationContext context) + { + Configure(options => + { + options.Resources + .Get() + .AddBaseTypes( + typeof(AbpUiResource) + ); + }); + } } diff --git a/modules/setting-management/src/Volo.Abp.SettingManagement.Blazor/AbpSettingManagementBlazorModule.cs b/modules/setting-management/src/Volo.Abp.SettingManagement.Blazor/AbpSettingManagementBlazorModule.cs index 8888df3596..533e272198 100644 --- a/modules/setting-management/src/Volo.Abp.SettingManagement.Blazor/AbpSettingManagementBlazorModule.cs +++ b/modules/setting-management/src/Volo.Abp.SettingManagement.Blazor/AbpSettingManagementBlazorModule.cs @@ -1,10 +1,13 @@ -using Microsoft.Extensions.DependencyInjection; +using Localization.Resources.AbpUi; +using Microsoft.Extensions.DependencyInjection; using Volo.Abp.AspNetCore.Components.Web.Theming; using Volo.Abp.AspNetCore.Components.Web.Theming.Routing; using Volo.Abp.AutoMapper; +using Volo.Abp.Localization; using Volo.Abp.Modularity; using Volo.Abp.SettingManagement.Blazor.Menus; using Volo.Abp.SettingManagement.Blazor.Settings; +using Volo.Abp.SettingManagement.Localization; using Volo.Abp.UI.Navigation; namespace Volo.Abp.SettingManagement.Blazor; @@ -39,5 +42,14 @@ public class AbpSettingManagementBlazorModule : AbpModule { options.Contributors.Add(new EmailingPageContributor()); }); + + Configure(options => + { + options.Resources + .Get() + .AddBaseTypes( + typeof(AbpUiResource) + ); + }); } } diff --git a/modules/tenant-management/src/Volo.Abp.TenantManagement.Blazor/AbpTenantManagementBlazorModule.cs b/modules/tenant-management/src/Volo.Abp.TenantManagement.Blazor/AbpTenantManagementBlazorModule.cs index 0296e377bb..0433f2e33b 100644 --- a/modules/tenant-management/src/Volo.Abp.TenantManagement.Blazor/AbpTenantManagementBlazorModule.cs +++ b/modules/tenant-management/src/Volo.Abp.TenantManagement.Blazor/AbpTenantManagementBlazorModule.cs @@ -1,11 +1,15 @@ -using Microsoft.Extensions.DependencyInjection; +using Localization.Resources.AbpUi; +using Microsoft.Extensions.DependencyInjection; using Volo.Abp.AspNetCore.Components.Web.Theming.Routing; using Volo.Abp.AutoMapper; using Volo.Abp.FeatureManagement.Blazor; +using Volo.Abp.FeatureManagement.Localization; +using Volo.Abp.Localization; using Volo.Abp.Modularity; using Volo.Abp.ObjectExtending; using Volo.Abp.ObjectExtending.Modularity; using Volo.Abp.TenantManagement.Blazor.Navigation; +using Volo.Abp.TenantManagement.Localization; using Volo.Abp.Threading; using Volo.Abp.UI.Navigation; @@ -38,6 +42,15 @@ public class AbpTenantManagementBlazorModule : AbpModule { options.AdditionalAssemblies.Add(typeof(AbpTenantManagementBlazorModule).Assembly); }); + + Configure(options => + { + options.Resources + .Get() + .AddBaseTypes( + typeof(AbpFeatureManagementResource), + typeof(AbpUiResource)); + }); } public override void PostConfigureServices(ServiceConfigurationContext context) diff --git a/templates/app-nolayers/aspnet-core/MyCompanyName.MyProjectName.Blazor.Server.Mongo/MyCompanyName.MyProjectName.Blazor.Server.Mongo.csproj b/templates/app-nolayers/aspnet-core/MyCompanyName.MyProjectName.Blazor.Server.Mongo/MyCompanyName.MyProjectName.Blazor.Server.Mongo.csproj index 22d4f51fbf..0983f7740c 100644 --- a/templates/app-nolayers/aspnet-core/MyCompanyName.MyProjectName.Blazor.Server.Mongo/MyCompanyName.MyProjectName.Blazor.Server.Mongo.csproj +++ b/templates/app-nolayers/aspnet-core/MyCompanyName.MyProjectName.Blazor.Server.Mongo/MyCompanyName.MyProjectName.Blazor.Server.Mongo.csproj @@ -7,8 +7,8 @@ - - + + diff --git a/templates/app-nolayers/aspnet-core/MyCompanyName.MyProjectName.Blazor.Server/MyCompanyName.MyProjectName.Blazor.Server.csproj b/templates/app-nolayers/aspnet-core/MyCompanyName.MyProjectName.Blazor.Server/MyCompanyName.MyProjectName.Blazor.Server.csproj index c840b24cbb..8573e93e48 100644 --- a/templates/app-nolayers/aspnet-core/MyCompanyName.MyProjectName.Blazor.Server/MyCompanyName.MyProjectName.Blazor.Server.csproj +++ b/templates/app-nolayers/aspnet-core/MyCompanyName.MyProjectName.Blazor.Server/MyCompanyName.MyProjectName.Blazor.Server.csproj @@ -7,8 +7,8 @@ - - + + diff --git a/templates/app/aspnet-core/src/MyCompanyName.MyProjectName.Blazor.Server.Tiered/MyCompanyName.MyProjectName.Blazor.Server.Tiered.csproj b/templates/app/aspnet-core/src/MyCompanyName.MyProjectName.Blazor.Server.Tiered/MyCompanyName.MyProjectName.Blazor.Server.Tiered.csproj index 0573ce737f..832bd8d7ba 100644 --- a/templates/app/aspnet-core/src/MyCompanyName.MyProjectName.Blazor.Server.Tiered/MyCompanyName.MyProjectName.Blazor.Server.Tiered.csproj +++ b/templates/app/aspnet-core/src/MyCompanyName.MyProjectName.Blazor.Server.Tiered/MyCompanyName.MyProjectName.Blazor.Server.Tiered.csproj @@ -13,8 +13,8 @@ - - + + diff --git a/templates/app/aspnet-core/src/MyCompanyName.MyProjectName.Blazor.Server/MyCompanyName.MyProjectName.Blazor.Server.csproj b/templates/app/aspnet-core/src/MyCompanyName.MyProjectName.Blazor.Server/MyCompanyName.MyProjectName.Blazor.Server.csproj index e1c5a68a56..eb34741aa4 100644 --- a/templates/app/aspnet-core/src/MyCompanyName.MyProjectName.Blazor.Server/MyCompanyName.MyProjectName.Blazor.Server.csproj +++ b/templates/app/aspnet-core/src/MyCompanyName.MyProjectName.Blazor.Server/MyCompanyName.MyProjectName.Blazor.Server.csproj @@ -13,8 +13,8 @@ - - + + diff --git a/templates/app/aspnet-core/src/MyCompanyName.MyProjectName.Blazor/MyCompanyName.MyProjectName.Blazor.csproj b/templates/app/aspnet-core/src/MyCompanyName.MyProjectName.Blazor/MyCompanyName.MyProjectName.Blazor.csproj index 923d27c148..53338ee686 100644 --- a/templates/app/aspnet-core/src/MyCompanyName.MyProjectName.Blazor/MyCompanyName.MyProjectName.Blazor.csproj +++ b/templates/app/aspnet-core/src/MyCompanyName.MyProjectName.Blazor/MyCompanyName.MyProjectName.Blazor.csproj @@ -11,8 +11,8 @@ - - + + diff --git a/templates/app/aspnet-core/src/MyCompanyName.MyProjectName.Blazor/wwwroot/index.html b/templates/app/aspnet-core/src/MyCompanyName.MyProjectName.Blazor/wwwroot/index.html index 5a6bb01acf..86839294ad 100644 --- a/templates/app/aspnet-core/src/MyCompanyName.MyProjectName.Blazor/wwwroot/index.html +++ b/templates/app/aspnet-core/src/MyCompanyName.MyProjectName.Blazor/wwwroot/index.html @@ -8,7 +8,7 @@ - + @@ -29,7 +29,7 @@ - + diff --git a/templates/module/aspnet-core/host/MyCompanyName.MyProjectName.Blazor.Host/MyCompanyName.MyProjectName.Blazor.Host.csproj b/templates/module/aspnet-core/host/MyCompanyName.MyProjectName.Blazor.Host/MyCompanyName.MyProjectName.Blazor.Host.csproj index 04772fc8e8..5177f6af11 100644 --- a/templates/module/aspnet-core/host/MyCompanyName.MyProjectName.Blazor.Host/MyCompanyName.MyProjectName.Blazor.Host.csproj +++ b/templates/module/aspnet-core/host/MyCompanyName.MyProjectName.Blazor.Host/MyCompanyName.MyProjectName.Blazor.Host.csproj @@ -8,8 +8,8 @@ - - + + diff --git a/templates/module/aspnet-core/host/MyCompanyName.MyProjectName.Blazor.Host/wwwroot/index.html b/templates/module/aspnet-core/host/MyCompanyName.MyProjectName.Blazor.Host/wwwroot/index.html index 1c7a8ec1ae..0ba799d6a9 100644 --- a/templates/module/aspnet-core/host/MyCompanyName.MyProjectName.Blazor.Host/wwwroot/index.html +++ b/templates/module/aspnet-core/host/MyCompanyName.MyProjectName.Blazor.Host/wwwroot/index.html @@ -8,7 +8,7 @@ - + @@ -22,7 +22,7 @@ - + diff --git a/templates/module/aspnet-core/host/MyCompanyName.MyProjectName.Blazor.Server.Host/MyCompanyName.MyProjectName.Blazor.Server.Host.csproj b/templates/module/aspnet-core/host/MyCompanyName.MyProjectName.Blazor.Server.Host/MyCompanyName.MyProjectName.Blazor.Server.Host.csproj index 4cb1ef18df..4557540843 100644 --- a/templates/module/aspnet-core/host/MyCompanyName.MyProjectName.Blazor.Server.Host/MyCompanyName.MyProjectName.Blazor.Server.Host.csproj +++ b/templates/module/aspnet-core/host/MyCompanyName.MyProjectName.Blazor.Server.Host/MyCompanyName.MyProjectName.Blazor.Server.Host.csproj @@ -12,8 +12,8 @@ - - + +