Merge branch 'dev' of https://github.com/abpframework/abp into pr/2519

docs/cs/CLI.md

@@ -129,6 +129,24 @@ abp update [možnosti]
 * `--npm`:  Aktualizuje pouze balíčky NPM.
 * `--nuget`: Aktualizuje pouze balíčky NuGet.
 
+### login
+
+Některé funkce CLI vyžadují přihlášení k platformě abp.io. Chcete-li se přihlásit pomocí svého uživatelského jména, napište
+
+```bash
+abp login <username>
+```
+
+Všimněte si, že nové přihlášení s již aktivní relací ukončí předchozí relaci a vytvoří novou.
+
+### logout
+
+Odhlásí vás odebráním tokenu relace z počítače.
+
+```
+abp logout
+```
+
 ### help
 
 Vypíše základní informace k používání CLI.

docs/cs/Entity-Framework-Core-PostgreSQL.md

@@ -1,74 +1,39 @@
-## Entity Framework Core PostgreSQL integrace
+# Přepnutí na EF Core PostgreSQL providera
 
-> Podívejte se na [Entity Framework Core integrační dokument](../Entity-Framework-Core.md) pro základy integrace EF Core.
+Tento dokument vysvětluje, jak přepnout na poskytovatele databáze **PostgreSQL** pro **[spouštěcí šablonu aplikace](Startup-Templates/Application.md)**, která je dodávána s předem nakonfigurovaným SQL poskytovatelem.
 
-### Aktualizace projektu EntityFrameworkCore
+## Výměna balíku Volo.Abp.EntityFrameworkCore.SqlServer
 
-- V projektu `Acme.BookStore.EntityFrameworkCore` nahraďte balík `Volo.Abp.EntityFrameworkCore.SqlServer` za `Volo.Abp.EntityFrameworkCore.PostgreSql` 
-- Aktualizace pro použití PostgreSQL v `BookStoreEntityFrameworkCoreModule`
-  - Nahraďte `AbpEntityFrameworkCoreSqlServerModule` za `AbpEntityFrameworkCorePostgreSqlModule`
-  - Nahraďte `options.UseSqlServer()` za `options.UsePostgreSql()`
-- V jiných projektech aktualizujte PostgreSQL connection string v nezbytných `appsettings.json` souborech
-  - Více informací v [PostgreSQL connection strings](https://www.connectionstrings.com/postgresql/), v tomto dokumentu věnujte pozornost sekci `Npgsql`
+Projekt `.EntityFrameworkCore` v řešení závisí na NuGet balíku [Volo.Abp.EntityFrameworkCore.SqlServer](https://www.nuget.org/packages/Volo.Abp.EntityFrameworkCore.SqlServer). Odstraňte tento balík a přidejte stejnou verzi balíku [Volo.Abp.EntityFrameworkCore.PostgreSql](https://www.nuget.org/packages/Volo.Abp.EntityFrameworkCore.PostgreSql).
 
-### Aktualizace projektu EntityFrameworkCore.DbMigrations
-- Aktualizace pro použití PostgreSQL v `XXXMigrationsDbContextFactory`
-  - Nahraďte `new DbContextOptionsBuilder<XXXMigrationsDbContext>().UseSqlServer()` za `new DbContextOptionsBuilder<XXXMigrationsDbContext>().UseNpgsql()`
+## Nahrazení závislosti modulu
 
+Najděte třídu ***YourProjectName*EntityFrameworkCoreModule** v projektu `.EntityFrameworkCore`, odstraňte `typeof(AbpEntityFrameworkCoreSqlServerModule)` z atributu `DependsOn`, přidejte `typeof(AbpEntityFrameworkCorePostgreSqlModule)` (také nahraďte `using Volo.Abp.EntityFrameworkCore.SqlServer;` za `using Volo.Abp.EntityFrameworkCore.PostgreSql;`).
 
-### Odstranění stávajících migrací
+## UsePostgreSql()
 
-Smažte všechny stavající migrační soubory (včetně `DbContextModelSnapshot`)
+Najděte volání `UseSqlServer()` v *YourProjectName*EntityFrameworkCoreModule.cs uvnitř projektu `.EntityFrameworkCore` a nahraďte za `UsePostgreSql()`.
 
-![postgresql-delete-initial-migrations](images/postgresql-delete-initial-migrations.png)
+Najděte volání `UseSqlServer()` v *YourProjectName*MigrationsDbContextFactory.cs uvnitř projektu `.EntityFrameworkCore.DbMigrations` a nahraďte za `UseNpgsql()`.
 
-### Znovu vygenerujte počáteční migraci
+> V závislosti na struktuře řešení můžete najít více volání `UseSqlServer()`, které je třeba změnit.
 
-Nastavte správný spouštěcí projekt (obvykle web projekt)
+## Změna connection stringů
 
-![set-as-startup-project](../images/set-as-startup-project.png)
+PostgreSql connection stringy se od těch pro SQL Server liší. Je proto potřeba zkontrolovat všechny soubory `appsettings.json` v řešení a connection stringy v nich nahradit. Podívejte se na [connectionstrings.com](https://www.connectionstrings.com/postgresql/) pro více detailů o možnostech PostgreSql connection stringů.
 
-Otevřete **Package Manager Console** (Tools -> Nuget Package Manager -> Package Manager Console), zvolte `.EntityFrameworkCore.DbMigrations` jako **Default project** a proveďte následující příkaz:
+Typicky je potřeba změnit `appsettings.json` v projektech `.DbMigrator` a `.Web` projects, ale to záleží na vaší struktuře řešení.
 
-Proveďte příkaz `Add-Migration`:
-````
-PM> Add-Migration Initial
-````
+## Regenerace migrací
 
-### Aktualizace databáze
+Startovací šablona používá [Entity Framework Core Code First migrace](https://docs.microsoft.com/en-us/ef/core/managing-schemas/migrations/). EF Core migrace závisí na zvoleném DBMS poskytovateli. Tudíž změna DBMS poskytovatele způsobí selhání migrace.
+* Smažte složku Migrations v projektu `.EntityFrameworkCore.DbMigrations` and znovu sestavte řešení.
+* Spusťte `Add-Migration "Initial"` v Package Manager Console (je nutné zvolit `.DbMigrator`  (nebo `.Web`) projekt jako startovací projekt v Solution Explorer a zvolit projekt `.EntityFrameworkCore.DbMigrations` jako výchozí v Package Manager Console).
 
-K vytvoření databáze máte dvě možnosti.
+Tímto vytvoříte migraci databáze se všemi nakonfigurovanými databázovými objekty (tabulkami).
 
-#### Použití DbMigrator aplikace
+Spusťte projekt `.DbMigrator` k vytvoření databáze a vložení počátečních dat.
 
-Řešení obsahuje konzolovou aplikaci (v tomto příkladu nazvanou `Acme.BookStore.DbMigrator`), která může vytvářet databáze, aplikovat migrace a vkládat seed data. Je užitečná jak pro vývojové, tak pro produkční prostředí.
+## Spuštění aplikace
 
-> Projekt `.DbMigrator` má vlastní `appsettings.json`. Takže pokud jste změnili connection string uvedený výše, musíte změnit také tento.
-
-Klikněte pravým na projekt `.DbMigrator` a vyberte **Set as StartUp Project**:
-
-![set-as-startup-project](images/set-as-startup-project.png)
-
-Zmáčkněte F5 (nebo Ctrl+F5) ke spuštění aplikace. Výstup bude vypadat následovně:
-
-![set-as-startup-project](images/db-migrator-app.png)
-
-#### Použití EF Core Update-Database příkazu
-
-Ef Core má `Update-Database` příkaz, který v případě potřeby vytvoří databázi a aplikuje čekající migrace.
-
-Nastavte správný spouštěcí projekt (obvykle web projekt)
-
-![set-as-startup-project](../images/set-as-startup-project.png)
-
-Otevřete **Package Manager Console** (Tools -> Nuget Package Manager -> Package Manager Console), vyberte projekt `.EntityFrameworkCore.DbMigrations` jako **Default Project** and spusťte následující příkaz:
-
-````
-PM> Update-Database
-````
-
-Dojde k vytvoření nové databáze na základě nakonfigurovaného connection stringu.
-
-![postgresql-update-database](images/postgresql-update-database.png)
-
-> Použití nástroje `.DbMigrator` je doporučený způsob, jelikož zároveň vloží seed data nutné k správnému běhu webové aplikace.
+Vše je připraveno. Stačí už jen spustit aplikaci a užívat si kódování.

docs/cs/docs-nav.json

@@ -60,6 +60,10 @@
           "text": "Konfigurace",
           "path": "Configuration.md"
         },
+        {
+          "text": "Možnosti",
+          "path": "Options.md"
+        },
         {
           "text": "Vkládání závislostí",
           "path": "Dependency-Injection.md",
@@ -83,7 +87,14 @@
           "path": "Exception-Handling.md"
         },
         {
-          "text": "Validace"
+          "text": "Validace",
+          "path": "Validation.md",
+          "items": [
+            {
+              "text": "FluentValidation integrace",
+              "path": "FluentValidation.md"
+            }
+          ]
         },
         {
           "text": "Autorizace",
@@ -257,24 +268,46 @@
     },
     {
       "text": "Přístup k datům",
+      "path": "Data-Access.md",
       "items": [
         {
-          "text": "Entity Framework Core integrace",
-          "path": "Entity-Framework-Core.md",
+          "text": "Connection stringy",
+          "path": "Connection-Strings.md"
+        },
+        {
+          "text": "Poskytovatelé databází",
           "items": [
             {
-              "text": "PostgreSQL integrace",
-              "path": "Entity-Framework-Core-PostgreSQL.md"
+              "text": "Entity Framework Core",
+              "path": "Entity-Framework-Core.md",
+              "items": [
+                {
+                  "text": "Přepnutí na MySQL",
+                  "path": "Entity-Framework-Core-MySQL.md"
+                },
+                {
+                  "text": "Přepnutí na PostgreSQL",
+                  "path": "Entity-Framework-Core-PostgreSQL.md"
+                },
+                {
+                  "text": "Přepnutí na SQLite",
+                  "path": "Entity-Framework-Core-SQLite.md"
+                },
+                {
+                  "text": "Přepnutí na jiný DBMS",
+                  "path": "Entity-Framework-Core-Other-DBMS.md"
+                }
+              ]
+            },
+            {
+              "text": "MongoDB",
+              "path": "MongoDB.md"
+            },
+            {
+              "text": "Dapper",
+              "path": "Dapper.md"
             }
           ]
-        },
-        {
-          "text": "MongoDB integrace",
-          "path": "MongoDB.md"
-        },
-        {
-          "text": "Dapper integrace",
-          "path": "Dapper.md"
         }
       ]
     },

docs/en/Ambient-Context-Pattern.md

@@ -0,0 +1,3 @@
+## Ambient Context Pattern
+
+TODO

docs/en/Audit-Logging.md

@@ -14,6 +14,11 @@ An **audit log object** (see the Audit Log Object section below) is typically cr
 
 > [Startup templates](Startup-Templates/Index.md) are configured for the audit logging system which is suitable for most of the applications. Use this document for a detailed control over the audit log system.
 
+### Database Provider Support
+
+* Fully supported by the [Entity Framework Core](Entity-Framework-Core.md) provider.
+* Entity change logging is not supported by the [MongoDB](MongoDB.md) provider. Other features work as expected.
+
 ## UseAuditing()
 
 `UseAuditing()` middleware should be added to the ASP.NET Core request pipeline in order to create and save the audit logs. If you've created your applications using [the startup templates](Startup-Templates/Index.md), it is already added.
@@ -282,6 +287,84 @@ Configure<AbpAuditingOptions>(options =>
 });
 ````
 
+## IAuditLogScope & IAuditingManager
+
+This section explains the `IAuditLogScope` & `IAuditingManager` services for advanced use cases.
+
+An **audit log scope** is an [ambient scope](Ambient-Context-Pattern.md) that **builds** and **saves** an audit log object (explained before). By default, an audit log scope is created for a web request by the Audit Log Middleware (see `UseAuditing()` section above).
+
+### Access to the Current Audit Log Scope
+
+Audit log contributors, was explained above, is a global way of manipulating the audit log object. It is good if you can get a value from a service.
+
+If you need to manipulate the audit log object in an arbitrary point of your application, you can access to the current audit log scope and get the current audit log object (independent of how the scope is managed). Example:
+
+````csharp
+public class MyService : ITransientDependency
+{
+    private readonly IAuditingManager _auditingManager;
+
+    public MyService(IAuditingManager auditingManager)
+    {
+        _auditingManager = auditingManager;
+    }
+
+    public async Task DoItAsync()
+    {
+        var currentAuditLogScope = _auditingManager.Current;
+        if (currentAuditLogScope != null)
+        {
+            currentAuditLogScope.Log.Comments.Add(
+                "Executed the MyService.DoItAsync method :)"
+            );
+            
+            currentAuditLogScope.Log.SetProperty("MyCustomProperty", 42);
+        }
+    }
+}
+````
+
+Always check if `_auditingManager.Current` is null or not, because it is controlled in an outer scope and you can't know if an audit log scope was created before calling your method.
+
+### Manually Create an Audit Log Scope
+
+You rarely need to create a manual audit log scope, but if you need, you can create an audit log scope using the `IAuditingManager` as like in the following example:
+
+````csharp
+public class MyService : ITransientDependency
+{
+    private readonly IAuditingManager _auditingManager;
+
+    public MyService(IAuditingManager auditingManager)
+    {
+        _auditingManager = auditingManager;
+    }
+
+    public async Task DoItAsync()
+    {
+        using (var auditingScope = _auditingManager.BeginScope())
+        {
+            try
+            {
+                //Call other services...
+            }
+            catch (Exception ex)
+            {
+                //Add exceptions
+                _auditingManager.Current.Log.Exceptions.Add(ex);
+            }
+            finally
+            {
+                //Always save the log
+                await auditingScope.SaveAsync();
+            }
+        }
+    }
+}
+````
+
+You can call other services, they may call others, they may change entities and so on. All these interactions are saved as a single audit log object in the finally block.
+
 ## The Audit Logging Module
 
 The Audit Logging Module basically implements the `IAuditingStore` to save the audit log objects to a database. It supports multiple database providers. This module is added to the startup templates by default.

docs/en/Entities.md

@@ -1,34 +1,27 @@
-## Entities
+# Entities
 
 Entities are one of the core concepts of DDD (Domain Driven Design). Eric Evans describe it as "*An object that is not fundamentally defined by its attributes, but rather by a thread of continuity and identity*".
 
 An entity is generally mapped to a table in a relational database.
 
-### Entity Class
+## Entity Class
 
-Entities are derived from `Entity<TKey>` class as shown below:
+Entities are derived from the `Entity<TKey>` class as shown below:
 
 ```C#
-public class Person : Entity<int>
+public class Book : Entity<Guid>
 {
     public string Name { get; set; }
 
-    public DateTime CreationTime { get; set; }
-
-    public Person()
-    {
-        CreationTime = DateTime.Now;
-    }
+    public float Price { get; set; }
 }
 ```
 
 > If you do not want to derive your entity from the base `Entity<TKey>` class, you can directly implement `IEntity<TKey>` interface.
 
-`Entity<TKey>` class just defines an `Id` property with the given primary **key type**, which is `int` in the sample above. It can be other types like `string`, `Guid`, `long` or whatever you need.
-
-Entity class also overrides the **equality** operator (==) to easily check if two entities are equal (they are equals if they are same entity type and their Ids are equals).
+`Entity<TKey>` class just defines an `Id` property with the given primary **key type**, which is `Guid` in the example above. It can be other types like `string`, `int`, `long` or whatever you need.
 
-#### Entities with Composite Keys
+### Entities with Composite Keys
 
 Some entities may need to have **composite keys**. In that case, you can derive your entity from the non-generic `Entity` class. Example:
 
@@ -53,31 +46,31 @@ public class UserRole : Entity
 }
 ````
 
-For the example above, the composite key is composed of `UserId` and `RoleId`. For a relational database, it is the composite primary key of the related table.
-
-Entities with composite keys should implement the `GetKeys()` method as shown above.
+For the example above, the composite key is composed of `UserId` and `RoleId`. For a relational database, it is the composite primary key of the related table. Entities with composite keys should implement the `GetKeys()` method as shown above.
 
-Notice that you also need to define keys of the entity in your **object-relational mapping** (ORM) configuration.
+> Notice that you also need to define keys of the entity in your **object-relational mapping** (ORM) configuration. See the [Entity Framework Core](Entity-Framework-Core.md) integration document for example.
 
-> Also note that Entities with Composite Primary Keys cannot utilize the `IRepository<TEntity, TKey>` interface since it requires a single unique Id property.  However, you can always use `IRepository<TEntity>`. See [repositories documentation](Repositories.md) for more.
+> Also note that Entities with Composite Primary Keys cannot utilize the `IRepository<TEntity, TKey>` interface since it requires a single Id property.  However, you can always use `IRepository<TEntity>`. See [repositories documentation](Repositories.md) for more.
 
 
-### AggregateRoot Class
+## AggregateRoot Class
 
 "*Aggregate is a pattern in Domain-Driven Design. A DDD aggregate is a cluster of domain objects that can be treated as a single unit. An example may be an order and its line-items, these will be separate objects, but it's useful to treat the order (together with its line items) as a single aggregate.*" (see the [full description](http://martinfowler.com/bliki/DDD_Aggregate.html))
 
-`AggregateRoot` class extends the `Entity` class. So, it also has an `Id` property by default.
+`AggregateRoot<TKey>` class extends the `Entity<TKey>` class. So, it also has an `Id` property by default.
 
-> Notice that ABP creates default repositories only for aggregate roots by default. However, it's possible to include all entities. See [repositories documentation](Repositories.md) for more. 
+> Notice that ABP creates default repositories only for aggregate roots by default. However, it's possible to include all entities. See the [repositories documentation](Repositories.md) for more. 
 
-ABP does not force you to use aggregate roots, you can in fact use the `Entity` class as defined before. However, if you want to implement DDD and want to create aggregate root classes, there are some best practices you may want to consider:
+ABP does not force you to use aggregate roots, you can in fact use the `Entity` class as defined before. However, if you want to implement the [Domain Driven Design](Domain-Driven-Design.md) and want to create aggregate root classes, there are some best practices you may want to consider:
 
 * An aggregate root is responsible to preserve it's own integrity. This is also true for all entities, but aggregate root has responsibility for it's sub entities too. So, the aggregate root must always be in a valid state.
 * An aggregate root can be referenced by it's Id. Do not reference it by it's navigation property.
 * An aggregate root is treated as a single unit. It's retrieved and updated as a single unit. It's generally considered as a transaction boundary.
 * Work with sub-entities over the aggregate root- do not modify them independently.
 
-#### Aggregate Example
+See the [entity design best practice guide](Best-Practices/Entities.md) if you want to implement DDD in your application.
+
+### Aggregate Example
 
 This is a full sample of an aggregate root with a related sub-entity collection:
 
@@ -156,6 +149,11 @@ public class OrderLine : Entity
     {
         Count = newCount;
     }
+    
+    public override object[] GetKeys()
+    {
+        return new Object[] {OrderId, ProductId};
+    }
 }
 ````
 
@@ -163,15 +161,80 @@ public class OrderLine : Entity
 
 `Order` is an **aggregate root** with `Guid` type `Id` property. It has a collection of `OrderLine` entities. `OrderLine` is another entity with a composite primary key (`OrderId`  and ` ProductId`).
 
-While this example may not implement all the best practices of an aggregate root, it still follows good practices:
+While this example may not implement all the best practices of an aggregate root, it still follows some good practices:
 
 * `Order` has a public constructor that takes **minimal requirements** to construct an `Order` instance. So, it's not possible to create an order without an id and reference number. The **protected/private** constructor is only necessary to **deserialize** the object while reading from a data source.
 * `OrderLine` constructor is internal, so it is only allowed to be created by the domain layer. It's used inside of the `Order.AddProduct` method.
 * `Order.AddProduct` implements the business rule to add a product to an order.
 * All properties have `protected` setters. This is to prevent the entity from arbitrary changes from outside of the entity. For exmple, it would be dangerous to set `TotalItemCount` without adding a new product to the order. It's value is maintained by the `AddProduct` method.
 
-ABP does not force you to apply any DDD rule or patterns. However, it tries to make it possible and easier when you do want to apply them. The documentation also follows the same principle.
+ABP Framework does not force you to apply any DDD rule or patterns. However, it tries to make it possible and easier when you do want to apply them. The documentation also follows the same principle.
 
-#### Aggregate Roots with Composite Keys
+### Aggregate Roots with Composite Keys
 
 While it's not common (and not suggested) for aggregate roots, it is in fact possible to define composite keys in the same way as defined for the mentioned entities above. Use non-generic `AggregateRoot` base class in that case.
+
+## Base Classes & Interfaces for Audit Properties
+
+There are some properties like `CreationTime`, `CreatorId`, `LastModificationTime`... which are very common in all applications. ABP Framework provides some interfaces and base classes to **standardize** these properties and also **sets their values automatically**.
+
+### Auditing Interfaces
+
+There are a lot of auditing interfaces, so you can implement the one that you need.
+
+> While you can manually implement these interfaces, you can use **the base classes** defined in the next section to simplify it.
+
+* `IHasCreationTime` defines the following properties:
+  * `CreationTime`
+* `IMayHaveCreator` defines the following properties:
+  * `CreatorId`
+* `ICreationAuditedObject` inherits from the `IHasCreationTime` and the `IMayHaveCreator`, so it defines the following properties:
+  * `CreationTime`
+  * `CreatorId`
+* `IHasModificationTime` defines the following properties:
+  * `LastModificationTime`
+* `IModificationAuditedObject` extends the `IHasModificationTime` and adds the `LastModifierId` property. So, it defines the following properties:
+  * `LastModificationTime`
+  * `LastModifierId`
+* `IAuditedObject` extends the `ICreationAuditedObject` and the `IModificationAuditedObject`, so it defines the following properties:
+  * `CreationTime`
+  * `CreatorId`
+  * `LastModificationTime`
+  * `LastModifierId`
+* `ISoftDelete` (see the [data filtering document](Data-Filtering.md)) defines the following properties:
+  * `IsDeleted`
+* `IHasDeletionTime` extends the `ISoftDelete` and adds the `DeletionTime` property. So, it defines the following properties:
+  * `IsDeleted`
+  * `DeletionTime` 
+* `IDeletionAuditedObject` extends the `IHasDeletionTime`  and adds the `DeleterId` property. So, it defines the following properties:
+  * `IsDeleted`
+  * `DeletionTime` 
+  * `DeleterId`
+* `IFullAuditedObject` inherits from the `IAuditedObject` and the `IDeletionAuditedObject`, so it defines the following properties:
+  * `CreationTime`
+  * `CreatorId`
+  * `LastModificationTime`
+  * `LastModifierId`
+  * `IsDeleted`
+  * `DeletionTime` 
+  * `DeleterId`
+
+Once you implement any of the interfaces, or derive from a class defined in the next section, ABP Framework automatically manages these properties wherever possible.
+
+> Implementing `ISoftDelete`, `IDeletionAuditedObject` or `IFullAuditedObject` makes your entity **soft-delete**. See the [data filtering document](Data-Filtering.md) to learn about the soft-delete pattern.
+
+### Auditing Base Classes
+
+While you can manually implement any of the interfaces defined above, it is suggested to inherit from the base classes defined here:
+
+* `CreationAuditedEntity<TKey>` and `CreationAuditedAggregateRoot<TKey>` implement the `ICreationAuditedObject` interface.
+* `AuditedEntity<TKey>` and `AuditedAggregateRoot<TKey>` implement the `IAuditedObject` interface.
+* `FullAuditedEntity<TKey>` and `FullAuditedAggregateRoot<TKey>` implement the `IFullAuditedObject` interface.
+
+All these base classes also have non-generic versions to take `AuditedEntity` and `FullAuditedAggregateRoot` to support the composite primary keys.
+
+All these base classes also have `...WithUser` pairs, like `FullAuditedAggregateRootWithUser<TUser>`  and`FullAuditedAggregateRootWithUser<TKey, TUser>`. This makes possible to add a navigation property to your user entity. However, it is not a good practice to add navigation properties between aggregate roots, so this usage is not suggested (unless you are using an ORM, like EF Core, that well supports this scenario and you really need it - otherwise remember that this approach doesn't work for NoSQL databases like MongoDB where you must truly implement the aggregate pattern).
+
+## See Also
+
+* [Best practice guide to design the entities](Best-Practices/Entities.md)

docs/zh-Hans/Blog-Posts/2020-01-15 v2_0_Release/Post.md

@@ -0,0 +1,164 @@
+# ABP框架v2.0 和 ABP商业版
+
+ABP框架2.0版已经在本周公布.这篇文章解释了为什么我们发布了一个**抢先主版本**,和2.0版本中的变化.
+
+除了v2.0版本,我们很高兴地宣布**ABP商业版**,这是建立在开源ABP框架的之上的一套专业的模块,工具,主题和服务.
+
+## ABP框架V2.0
+
+### 为什么2.0,而不是1.2？
+
+本来在[V1.1.2](https://github.com/abpframework/abp/releases/tag/1.1.2)发布后计划发布1.2版.然而,[有报告](https://github.com/abpframework/abp/issues/2026)称1.x版在Linux上有一些**性能**和**稳定性**问题,尤其是当应用程序部署在**低配CPU和内存**的**Linux**容器上.
+
+我们深入研究了这一问题,并已查明问题的根本原因与**拦截`async`方法**的实现有关.此外,也有一些 **`async`套`sync`** 的用法影响了线程池的优化.
+
+最后,在**社区**在大力协助下我们**解决了所有的问题**.但是,我们也有一些重要的**设计决策**导致了一些**破坏性变更**,因为[语义版本](https://semver.org/),我们不得不改变框架的主版号.
+
+大多数的应用程序不会受到[破坏性变更](https://github.com/abpframework/abp/releases)的影响,或者只需要做一些微小的修改.
+
+### 破坏性变更
+
+#### 删除了一些同步的API
+
+一些拦截器需要使用`async`的API.当他们拦截`sync`方法时,他们需要调用`async`套`sync`.这最终导致了`async`套`sync`的问题.这就是为什么我们[删除了一些同步的API](https://github.com/abpframework/abp/pull/2464).
+
+当你需要**在`async`方法中调用`sync`方法**时, **`async`套`sync`** 这种模式是`C#`一个经典问题.虽然有一些解决方法,但是都有相应的**缺点**,并建议**不要写**这样的代码.你可以在网上找到关于这一话题的许多文档.
+
+为了避免这个问题,我们已经移除:
+
+- `sync`[仓储](https://docs.abp.io/en/abp/latest/Repositories)方法 (如`insert`, `update`, 等...),
+- `sync`[工作单元](https://docs.abp.io/en/abp/latest/Unit-Of-Work)API,
+- `sync`[后台作业](https://docs.abp.io/en/abp/latest/Background-Jobs)API,
+- `sync`[审计日志](https://docs.abp.io/en/abp/latest/Audit-Logging)API,
+ - 其他一些很少使用的`sync`API.
+
+如果你遇到了编译错误,只需使用这些API的`async`版本.
+
+#### 始终async!
+
+从v2.0开始,ABP框架假设你以`async`方式编写你的应用程序代码.否则,一些框架的功能可能无法正常工作.
+
+建议你的所有[应用服务](https://docs.abp.io/en/abp/latest/Application-Services), [仓储方法](https://docs.abp.io/en/abp/latest/Repositories), 控制器动作(ontroller actions), 页面处理器(page handlers)都是`async`.
+
+即使你的应用服务方法并不需要是`async`,也将其设置为`async`,因为拦截器需要执行`async`操作（授权,工作单元等）.你可以在不调用`async`的方法中返回`Task.Completed`.
+
+示例:
+
+````csharp
+public Task<int> GetValueAsync()
+{
+    //这个方法没有任何async调用
+    return Task.CompletedTask(42);
+}
+````
+
+上述例子通常并不需要是`async`因为它不执行`async`调用.然而,将它设置为`async`,这样可以帮助ABP框架运行拦截器时避免出现`async`套sync的调用.
+
+此规则不强制你写的每一个方法都是`async`.这样并不好而且很乏味.只在拦截的服务上需要(特别是[应用服务](https://docs.abp.io/en/abp/latest/Application-Services)和[仓库方法](https://docs.abp.io/en/abp/latest/Repositories))
+
+#### 其他破坏性变更
+
+查看[发行说明](https://github.com/abpframework/abp/releases/tag/2.0.0)中的破坏性变更.他们中的大多数都不会影响你的应用程序代码.
+
+### 新功能
+
+本次发布还包含一些新的功能和一堆改进:
+
+- [#2597](https://github.com/abpframework/abp/pull/2597) 新的`Volo.Abp.AspNetCore.Serilog`包.
+- [#2526](https://github.com/abpframework/abp/issues/2526) `C#`客户端代理的客户端验证.
+- [#2374](https://github.com/abpframework/abp/issues/2374) `async`后台作业.
+- [#265](https://github.com/abpframework/abp/issues/265) 管理应用程序关闭.
+- [#2472](https://github.com/abpframework/abp/issues/2472) `IdentityServer`模块实现`DeviceFlowCodes`和`TokenCleanupService`.
+
+功能,改进和BUG修复的完整列表, 请查看[发布说明](https://github.com/abpframework/abp/releases/tag/2.0.0).
+
+### 文档
+
+随着v2.0的发布,我们也完成了一些缺少的文档.在接下来的几周内,我们将主要关注文档和教程.
+
+## ABP商业版
+
+[ABP商业版](https://commercial.abp.io/)是建立在开源ABP框架之上的一套专业的**模块,工具,主题和服务**.
+
+ - 除了ABP框架免费和[开源模块](https://docs.abp.io/en/abp/latest/Modules/Index)之外, 提供[专业模块](https://commercial.abp.io/modules).
+- 包含一个漂亮的[UI主题](https://commercial.abp.io/themes), 具有5种不同的样式.
+- 提供[ABP套件](https://commercial.abp.io/tools/suite); 一个让开发更具有生产力的工具. 通过配置实体属性, 它可以在几秒内创建全栈的CRUD页面. 更多的功能陆续开发中.
+- 为企业提供[高级支持](ttps://commercial.abp.io/support).
+
+除了这些标准的功能,我们会将提供定制服务.更多细节请参见[commercial.abp.io](https://commercial.abp.io/)网站.
+
+### ABP框架 vs ABP商业版
+
+ABP商业版**不是付费版本**的ABP框架.可以把它当作为专业公司提供的**附加套餐**.你可以用它来节省时间和更快地开发产品.
+
+ABP框架将永远是**开源免费**的!
+
+一个原则是,我们创建的主要基础设施作为开源产品, 然后销售额外的预制应用程序功能,主题和工具.类似于[ASP.NET Boilerplate](https://aspnetboilerplate.com/)和[ASP.NET Zero](https://aspnetzero.com/)产品.
+
+购买商业版许可极大地节省你的时间和精力,你可以专注于自己的业务,此外也可获得专门的和优先的支持.同时,你也在支持ABP核心团队,因为我们花了大部分时间来开发,维护和支持开源的ABP框架.
+
+有了ABP商业版,ABP现在变为一个平台.我们称之为**ABP.IO平台**, 其中包括开源ABP框架和ABP商业版.
+
+### 演示
+
+如果你想知道ABP商业版应用程序的启动模板是什么样,你可以很容易地[创建一个演示](https://commercial.abp.io/demo),并看到它的实际效果.该演示包括所有的预制模块和主题.
+
+下面是一张IdentityServer管理模块UI的截图:
+
+![abp-commercial-demo](abp-commercial-demo.png)
+
+这是一张来自使用material设计风格主题的演示应用程序的截图:
+
+![lepton-theme-material](lepton-theme-material.png)
+
+### 价格
+
+你可以创建**无限个工程/产品**, 销售给**无限个客户**, 部署在**无限台服务器上**, 不受任何限制. 定价主要是基于**开发人员个数**,**支持等级**和**源代码**需求上.有三个标准包;
+
+- **团队许可**: 包括所有的模块,主题和工具.允许最多3个开发者开发产品.可购买额外的开发者许可.
+- **商业许可**: 允许下载所有的模块和主题的源代码.此外,默认包含了5个开发者许可.可购买额外的开发者许可.
+- **企业许可**: 在商业许可上, 提供无限的专属支持.
+
+请查看[价格页面](https://commercial.abp.io/pricing)了解详细信息.除了标准包以外,我们也提供定制服务和定制许可.如有任何问题,请[联系我们](https://commercial.abp.io/contact).
+
+#### 许可比较
+
+许可价格是根据开发者数量,支持等级和源代码访问而变化的.
+
+##### 源代码
+
+团队许可证不包括预制模块和主题的源代码.以**NuGet和NPM包**的方式使用所有这些模块.通过这种方式,你可以很容易地通过更新包的依赖得到**新功能和bug修复**仅.但是不能访问其源代码.所以不能嵌入模块的源代码到你的应用程序里,和随意修改源代码.
+
+预制模块提供一定等级的**定制**和**扩展**,并允许你覆盖服务,UI部分等.我们正在努力使他们更加可定制和可扩展.如果你无需在预制模块中做很大修改的话,团队许可是你理想的选择,因为它更便宜,并且可轻松获得新的功能和bug修复.
+
+商业和企业许可允许你在需要时**下载任何模块和主题的源代码**.它们使用与团队许可相同的启动模板,所以所有的模块都默认使用`NuGet`和`NPM`包.但是,在需要的情况下,你可以从一个模块中删除包的依赖,并嵌入它的源代码到你自己的解决方案中,然后完全定制它.在这种情况下,当一个新版本可用时, 升级模块将不会那么容易.当然, 你不必升级!但是,如果你愿意,你也可以使用一些合并工具或Git的分支系统来做到这一点.
+
+#### 许可周期
+
+ABP商业版许可是**永久的**,这意味着你可以**永远使用**它继续开发应用程序.
+
+但是,下面的服务周期为一年:
+
+- 高级**支持**一年后结束.你可以继续得到社区支持.
+- 一年后将不会得到模块和主题的**更新**.你可以继续使用最后获得的版本.甚至可以在主版本内得到BUG修复和改进.
+- 你可使用**ABP套件**一年.
+
+如果想继续获得这些好处,可延长许可期限.续订价格比正常价格低20%.
+
+## NDC London 2020
+
+与[去年](https://medium.com/volosoft/impressions-of-ndc-london-2019-f8f391bb7a9c)一样, 我们是著名的软件开发会议[NDC London](https://ndc-london.com/)的合作伙伴! 去年, 我们开展了[ASP.NET Boilerplate](https://aspnetboilerplate.com/)和[ASP.NET Zero](https://aspnetzero.com/)主题:
+
+![ndc-london-volosoft](ndc-london-volosoft.png)
+
+今年,我们将着重于**ABP.IO平台**(开源ABP框架和ABP商业版).我们的展位会是这样的:
+
+![ndc-london-volosoft](ndc-2020-volosoft-booth-wall.png)
+
+如果你参加会议,记得要参观我们的展位.我们将很高兴来谈一谈ABP平台的功能,目标和软件开发.
+
+### 你想见ABP团队吗?
+
+如果你在伦敦, 而且想和我们喝杯咖啡的话, 在2月1日的下午[@hibrahimkalkan](https://twitter.com/hibrahimkalkan)和[@ismcagdas](https://twitter.com/ismcagdas)会在那.
+
+想见面就给info@abp.io写个邮件 :)

framework/src/Volo.Abp.Cli.Core/Volo/Abp/Cli/ProjectModification/SolutionModuleAdder.cs

@@ -106,6 +106,11 @@ namespace Volo.Abp.Cli.ProjectModification
                 return;
             }
 
+            if (string.IsNullOrWhiteSpace(startupProject))
+            {
+                startupProject = projectFiles.FirstOrDefault(p => p.EndsWith(".DbMigrator.csproj"));
+            }
+
             var dbMigrationsProject = projectFiles.FirstOrDefault(p => p.EndsWith(".DbMigrations.csproj"));
             
             if (dbMigrationsProject == null)

framework/src/Volo.Abp.Emailing/Volo/Abp/Emailing/Localization/cs.json

@@ -0,0 +1,24 @@
+{
+  "culture": "cs",
+  "texts": {
+    "DisplayName:Abp.Mailing.DefaultFromAddress": "Výchozí adresa odesílatele",
+    "DisplayName:Abp.Mailing.DefaultFromDisplayName": "Výchozí zobrazované jméno odesilátele",
+    "DisplayName:Abp.Mailing.Smtp.Host": "Hostitel",
+    "DisplayName:Abp.Mailing.Smtp.Port": "Port",
+    "DisplayName:Abp.Mailing.Smtp.UserName": "Uživatelské jméno",
+    "DisplayName:Abp.Mailing.Smtp.Password": "Heslo",
+    "DisplayName:Abp.Mailing.Smtp.Domain": "Doména",
+    "DisplayName:Abp.Mailing.Smtp.EnableSsl": "Povolit SSL",
+    "DisplayName:Abp.Mailing.Smtp.UseDefaultCredentials": "Použít výchozí přihlašovací údaje",
+    "Description:Abp.Mailing.DefaultFromAddress": "Výchozí adresa odesílatele",
+    "Description:Abp.Mailing.DefaultFromDisplayName": "Výchozí zobrazované jméno odesilátele",
+    "Description:Abp.Mailing.Smtp.Host": "Název nebo IP adresa hostitele použitého pro SMTP transakce.",
+    "Description:Abp.Mailing.Smtp.Port": "Port použitý pro SMTP tansakce",
+    "Description:Abp.Mailing.Smtp.UserName": "Uživatelské jméno spojené s přihlašovacími údaji.",
+    "Description:Abp.Mailing.Smtp.Password": "Heslo pro uživatelské jméno spojené s přihlašovacími údaji.",
+    "Description:Abp.Mailing.Smtp.Domain": "Název domény nebo počítače, který ověřuje přihlašovací údaje.",
+    "Description:Abp.Mailing.Smtp.EnableSsl": "Zda SmtpClient používá SSL k šifrování připojení.",
+    "Description:Abp.Mailing.Smtp.UseDefaultCredentials": "Zda jsou výchozí přihlašovací údaje odesílány s požadavky."
+  }
+}
+ 

framework/src/Volo.Abp.Localization/Volo/Abp/Localization/Resources/AbpLocalization/cs.json

@@ -0,0 +1,7 @@
+{
+  "culture": "cs",
+  "texts": {
+    "DisplayName:Abp.Localization.DefaultLanguage": "Výchozí jazyk",
+    "Description:Abp.Localization.DefaultLanguage": "Váchozí jazyk aplikace."
+  }
+}

modules/account/src/Volo.Abp.Account.Application.Contracts/Volo/Abp/Account/Localization/Resources/cs.json

@@ -35,6 +35,10 @@
     "PasswordChanged": "Heslo změněno",
     "NewPasswordConfirmFailed": "Potvrďte nové heslo.",
     "Manage": "Spravovat",
-    "ManageYourProfile": "Spravujte svůj profil"
+    "ManageYourProfile": "Spravujte svůj profil",
+    "DisplayName:Abp.Account.IsSelfRegistrationEnabled": "Je povolena automatická registrace",
+    "Description:Abp.Account.IsSelfRegistrationEnabled": "Zda si uživatel může účet zaregistrovat sám.",
+    "DisplayName:Abp.Account.EnableLocalLogin": "Ověření pomocí místního účtu",
+    "Description:Abp.Account.EnableLocalLogin": "Označuje, zda server umožní uživatelům ověřovat se pomocí místního účtu."
   }
 }

modules/docs/src/Volo.Docs.Domain/Volo/Docs/Localization/Domain/cs.json

@@ -15,6 +15,7 @@
     "DocumentNotFound": "Ups, vyžádaný dokument neexistuje!",
     "NavigationDocumentNotFound": "Tato verze nemá navigační dokument!",
     "DocumentNotFoundInSelectedLanguage": "Tento dokument není dostupný ve vybraném jazyce. Zobrazen dokument ve výchozím jazyce.",
-    "FilterTopics": "Filtrovat témata"
+    "FilterTopics": "Filtrovat témata",
+    "MultipleVersionDocumentInfo": "Tento dokument má více verzí. Vyberte možnosti, které vám nejlépe vyhovují."
   }
 }

modules/identity/src/Volo.Abp.Identity.Domain.Shared/Volo/Abp/Identity/Localization/cs.json

@@ -71,6 +71,32 @@
     "Permission:Delete": "Smazat",
     "Permission:ChangePermissions": "Změnit oprávnění",
     "Permission:UserManagement": "Správa uživatelů",
-    "Permission:UserLookup": "Vyhledání uživatele"
+    "Permission:UserLookup": "Vyhledání uživatele",
+    "DisplayName:Abp.Identity.Password.RequiredLength": "Požadovaná délka",
+    "DisplayName:Abp.Identity.Password.RequiredUniqueChars": "Požadovaný počet unikátních znaků",
+    "DisplayName:Abp.Identity.Password.RequireNonAlphanumeric": "Požadován nealfanumerický znak",
+    "DisplayName:Abp.Identity.Password.RequireLowercase": "Požadováno malé písmeno",
+    "DisplayName:Abp.Identity.Password.RequireUppercase": "Požadováno velké písmeno",
+    "DisplayName:Abp.Identity.Password.RequireDigit": "Požadováno číslo",
+    "DisplayName:Abp.Identity.Lockout.AllowedForNewUsers": "Povoleno pro nové uživatele",
+    "DisplayName:Abp.Identity.Lockout.LockoutDuration": "Délka blokování (sekundy)",
+    "DisplayName:Abp.Identity.Lockout.MaxFailedAccessAttempts": "Maximální počet neúspěšných pokusů o přístup",
+    "DisplayName:Abp.Identity.SignIn.RequireConfirmedEmail": "Požadovat potvrzený email",
+    "DisplayName:Abp.Identity.SignIn.RequireConfirmedPhoneNumber": "Požadovat potvrzené telefonní číslo",
+    "DisplayName:Abp.Identity.User.IsUserNameUpdateEnabled": "Je povolena změna uživatelského jména",
+    "DisplayName:Abp.Identity.User.IsEmailUpdateEnabled": "Je povolena změna emailu",
+    "Description:Abp.Identity.Password.RequiredLength": "Minimální délka hesla.",
+    "Description:Abp.Identity.Password.RequiredUniqueChars": "Minimální počet jedinečných znaků, které musí heslo obsahovat.",
+    "Description:Abp.Identity.Password.RequireNonAlphanumeric": "Hesla musí obsahovat nealfanumerický znak.",
+    "Description:Abp.Identity.Password.RequireLowercase": "Pokud hesla musí obsahovat ASCII znak malých písmen.",
+    "Description:Abp.Identity.Password.RequireUppercase": "Pokud hesla musí obsahovat ASCII znak velkých písmen.",
+    "Description:Abp.Identity.Password.RequireDigit": "Pokud hesla musí obsahovat číslici.",
+    "Description:Abp.Identity.Lockout.AllowedForNewUsers": "Zda může být uzamčen nový uživatel.",
+    "Description:Abp.Identity.Lockout.LockoutDuration": "Doba, po kterou je uživatel zablokován, když dojde k zablokování.",
+    "Description:Abp.Identity.Lockout.MaxFailedAccessAttempts": "Počet neúspěšných pokusů o přístup než je uživatel uzamčen, za předpokladu, že je uzamčení povoleno.",
+    "Description:Abp.Identity.SignIn.RequireConfirmedEmail": "Zda je k přihlášení vyžadována potvrzená emailová adresa.",
+    "Description:Abp.Identity.SignIn.RequireConfirmedPhoneNumber": "Zda je pro přihlášení vyžadováno potvrzené telefonní číslo.",
+    "Description:Abp.Identity.User.IsUserNameUpdateEnabled": "Zda může uživatel změnit uživatelské jméno.",
+    "Description:Abp.Identity.User.IsEmailUpdateEnabled": "Zda může uživatel změnit email."
   }
 }