Merge pull request #1477 from Xeevis/localization-cs

[Docs] Czech localization update

docs/cs/Contribution/Index.md

@@ -29,6 +29,14 @@ Pokud chcete přeložit celou [dokumentaci](https://abp.io/documents/) (včetně
 * Pro referenci použijte ["en" složku](https://github.com/abpframework/abp/tree/master/docs/en) a její názvy souborů a strom složek. Při překladu této dokumentace zachovejte prosím tyto názvy stejné.
 * Zašlete pull request (PR) po překladu jakéhokoliv dokumentu klidně i po jednom. Nečekejte až budete mít překlad všech dokumentů.
 
+Existuje několik základních dokumentů, které je třeba přeložit než bude jazyk uveřejněn na [stránkách ABP dokumentace](https://docs.abp.io)
+
+* Začínáme dokumenty
+* Tutoriály
+* CLI
+
+Nový jazyk je publikován jakmile budou minimálně tyto překlady dokončeny.
+
 ### Lokalizace zdrojů
 
 ABP framework má flexibilní [lokalizační systém](../Localization.md). Můžete tak vytvořit lokalizované uživatelské prostředí pro svou vlastní aplikaci.

docs/cs/Getting-Started-AspNetCore-Application.md

@@ -0,0 +1,186 @@
+# Začínáme s ASP.NET Core MVC aplikací
+
+Tento tutoriál vysvětluje jak začít s ABP z ničeho s minimem závislostí. Obvykle chcete začít se **[startovací šablonou](https://abp.io/Templates)**.
+
+## Tvorba nového projektu
+
+1. Vytvořte novou prázdnou AspNet Core Web aplikaci ve Visual Studio:
+
+![](images/create-new-aspnet-core-application.png)
+
+2. Zvolte prázdnou šablonu
+
+![](images/select-empty-web-application.png)
+
+Můžete zvolit i jinou šablonu, ale pro demonstraci je lepší čístý projekt.
+
+## Instalace Volo.Abp.AspNetCore.Mvc balíku
+
+Volo.Abp.AspNetCore.Mvc je AspNet Core MVC integrační balík pro ABP. Takže ho nainstalujeme do projektu:
+
+````
+Install-Package Volo.Abp.AspNetCore.Mvc
+````
+
+## Tvorba prvního ABP modulu
+
+ABP je modulární framework a proto vyžaduje **spouštěcí (kořenový) modul** což je třída dědící z ``AbpModule``:
+
+````C#
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.Extensions.DependencyInjection;
+using Volo.Abp;
+using Volo.Abp.AspNetCore.Modularity;
+using Volo.Abp.AspNetCore.Mvc;
+using Volo.Abp.Modularity;
+
+namespace BasicAspNetCoreApplication
+{
+    [DependsOn(typeof(AbpAspNetCoreMvcModule))]
+    public class AppModule : AbpModule
+    {
+        public override void OnApplicationInitialization(ApplicationInitializationContext context)
+        {
+            var app = context.GetApplicationBuilder();
+            var env = context.GetEnvironment();
+
+            if (env.IsDevelopment())
+            {
+                app.UseDeveloperExceptionPage();
+            }
+
+            app.UseMvcWithDefaultRoute();
+        }
+    }
+}
+````
+
+``AppModule`` je dobrý název pro spouštěcí modul aplikace.
+
+ABP balíky definují modulové třídy a modul může mít závislost na jiný modul. V kódu výše, náš ``AppModule`` má závislost na ``AbpAspNetCoreMvcModule`` (definován v balíku Volo.Abp.AspNetCore.Mvc). Je běžné přidat ``DependsOn`` atribute po instalaci nového ABP NuGet balíku.
+
+Místo třídy Startup, konfigurujeme ASP.NET Core pipeline v této modulové třídě.
+
+## Třída Startup
+
+V dalším kroku upravíme Startup třídu k integraci ABP modulového systému:
+
+````C#
+using System;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace BasicAspNetCoreApplication
+{
+    public class Startup
+    {
+        public IServiceProvider ConfigureServices(IServiceCollection services)
+        {
+            services.AddApplication<AppModule>();
+
+            return services.BuildServiceProviderFromFactory();
+        }
+
+        public void Configure(IApplicationBuilder app)
+        {
+            app.InitializeApplication();
+        }
+    }
+}
+
+````
+
+Změnili jsme metodu ``ConfigureServices`` aby vracela ``IServiceProvider`` místo ``void``. Tato změna nám dovoluje nahradit AspNet Core vkládání závislostí za jiný framework (více v sekci Autofac integrace níže). ``services.AddApplication<AppModule>()`` přidává všechny služby definované ve všech modulech počínaje ``AppModule``.
+
+Volání ``app.InitializeApplication()`` v metodě ``Configure`` inicializuje a spustí aplikaci.
+
+## Ahoj světe!
+
+Aplikace výše zatím nic nedělá. Pojďme proto vytvořit MVC controller, který už něco dělá:
+
+````C#
+using Microsoft.AspNetCore.Mvc;
+using Volo.Abp.AspNetCore.Mvc;
+
+namespace BasicAspNetCoreApplication.Controllers
+{
+    public class HomeController : AbpController
+    {
+        public IActionResult Index()
+        {
+            return Content("Hello World!");
+        }
+    }
+}
+
+````
+
+Jakmile spustíte aplikaci, uvidíte na stránce zprávu "Hello World!".
+
+Odvození ``HomeController`` od ``AbpController`` místo standardní třídy ``Controller``. Toto není vyžadováno, ale třída ``AbpController`` má užitečné základní vlastnosti a metody, které usnadňují vývoj.
+
+## Použití Autofac jako frameworku pro vkládání závislostí
+
+Ačkoliv je AspNet Core systém pro vkládání závíslostí (DI) skvělý pro základní požadavky, Autofac poskytuje pokročilé funkce jako injekce vlastností nebo záchyt metod, které jsou v ABP užity k provádění pokročilých funkcí frameworku.
+
+Nahrazení AspNet Core DI systému za Autofac a integrace s ABP je snadná.
+
+1. Nainstalujeme [Volo.Abp.Autofac](https://www.nuget.org/packages/Volo.Abp.Autofac) balík
+
+````
+Install-Package Volo.Abp.Autofac
+````
+
+2. Přidáme ``AbpAutofacModule`` závislost
+
+````C#
+[DependsOn(typeof(AbpAspNetCoreMvcModule))]
+[DependsOn(typeof(AbpAutofacModule))]  // Přidá závislost na AbpAutofacModule
+public class AppModule : AbpModule
+{
+    ...
+}
+````
+
+3. Změníme řádek ``services.AddApplication<AppModule>();`` v třídě ``Startup`` následovně:
+
+````C#
+services.AddApplication<AppModule>(options =>
+{
+    options.UseAutofac(); // Integrace s Autofac
+});
+````
+
+4. Upravíme `Program.cs` aby nepoužíval metodu `WebHost.CreateDefaultBuilder()` jelikož ta používá výchozí DI kontejner:
+
+````csharp
+public class Program
+{
+    public static void Main(string[] args)
+    {
+        /*
+            https://github.com/aspnet/AspNetCore/issues/4206#issuecomment-445612167
+            CurrentDirectoryHelpers exists in: \framework\src\Volo.Abp.AspNetCore.Mvc\Microsoft\AspNetCore\InProcess\CurrentDirectoryHelpers.cs
+            Will remove CurrentDirectoryHelpers.cs when upgrade to ASP.NET Core 3.0.
+        */
+        CurrentDirectoryHelpers.SetCurrentDirectory();
+
+        BuildWebHostInternal(args).Run();
+    }
+
+    public static IWebHost BuildWebHostInternal(string[] args) =>
+        new WebHostBuilder()
+            .UseKestrel()
+            .UseContentRoot(Directory.GetCurrentDirectory())
+            .UseIIS()
+            .UseIISIntegration()
+            .UseStartup<Startup>()
+            .Build();
+}
+````
+
+## Zdrojový kód
+
+Získejte zdrojový kód vzorového projektu vytvořeného v tomto tutoriálů [z tohoto odkazu](https://github.com/abpframework/abp/tree/master/samples/BasicAspNetCoreApplication).
+

docs/cs/Getting-Started-AspNetCore-MVC-Template.md

@@ -0,0 +1,102 @@
+## Začínáme s ASP.NET Core MVC šablonou
+
+Tento tutoriál vysvětluje, jak vytvořit novou ASP.NET Core MVC webovou aplikaci pomocí úvodní šablony, jak ji nakonfigurovat a spustit.
+
+### Tvorba nového projektu
+
+Tento tutoriál používá k tvorbě nového projektu **ABP CLI**. Podívejte se na stránku [Začínáme](https://abp.io/get-started) pro více možností.
+
+Pokud ještě nemáte ABP CLI nainstalováno, učiňte tak pomocí okna příkazového řádku:
+
+````bash
+dotnet tool install -g Volo.Abp.Cli
+````
+
+K tvorbě vašeho projektu použijte příkaz `abp new` v prázdné složce:
+
+````bash
+abp new Acme.BookStore
+````
+
+> Můžete použít různé úrovně jmenných prostorů; např. BookStore, Acme.BookStore nebo Acme.Retail.BookStore.
+
+Příkaz `new` vytvoří **vrstvenou MVC aplikaci** s **Entity Framework Core** jako databázovým poskytovatelem. Jsou zde však i jiné možnosti. Podívejte se na [CLI dokumnentaci](CLI.md) pro všechny další možností.
+
+#### Požadavky
+
+Vytvořené řešení vyžaduje;
+
+* [Visual Studio 2017 (v15.9.0+)](https://visualstudio.microsoft.com/tr/downloads/)
+* [.NET Core 2.2+](https://www.microsoft.com/net/download/dotnet-core/)
+
+### Struktura řešení
+
+Otevřete řešení ve **Visual Studio**:
+
+![bookstore-visual-studio-solution](images/bookstore-visual-studio-solution-v3.png)
+
+Řešení má vrstvenou strukturu (založenou na [Domain Driven Design](Domain-Driven-Design.md)) a obsahuje projekty jednotkovových a integračních testů předkonfigurované pro práci s **EF Core** & **SQLite in-memory** databází.
+
+> Podívejte se na [dokument šablony MVC aplikace](Startup-Templates/Mvc.md) k detailnímu pochopení struktury řešení.
+
+### Connection string databáze
+
+Zkontrolujte **connection string** v souboru `appsettings.json` v projektu `.Web`:
+
+````json
+{
+  "ConnectionStrings": {
+    "Default": "Server=localhost;Database=BookStore;Trusted_Connection=True"
+  }
+}
+````
+
+Řešení je nakonfigurováno k používání **Entity Framework Core** s **MS SQL Server**. EF Core podporuje [různé](https://docs.microsoft.com/en-us/ef/core/providers/) databázové poskytovatele, takže můžete použít i jiné DBMS. V případě potřeby změňte connection string.
+
+### Tvorba databáze & aplikace databázových migrací
+
+K vytvoření databáze máte dvě možnosti.
+
+#### Použití DbMigrator aplikace
+
+Ř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í.
+
+> 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. Klikněte pravým na projekt `.Web` a vyberte **Set as StartUp Project**:
+
+![set-as-startup-project](images/set-as-startup-project.png)
+
+Otevřete **Package Manager Console**, vyberte projekt `.EntityFrameworkCore.DbMigrations` jako **Default Project** and spusťte příkaz `Update-Database`:
+
+![pcm-update-database](images/pcm-update-database-v2.png)
+
+Dojde k vytvoření nové databáze na základě nakonfigurovaného connection stringu.
+
+> Použití nástroje `.Migrator` je doporučený způsob, jelikož zároveň vloží seed data nutné k správnému běhu webové aplikace.
+
+### Spuštění aplikace
+
+Ujistěte se že je projekt `.Web` nastaven jako startovací projekt. Spusťte aplikaci což následně otevře **úvodní** stránku ve vašem prohlížeči:
+
+![bookstore-homepage](images/bookstore-homepage.png)
+
+Klikněte na tlačítko **Přihlásit**, vložte `admin` jako uživatelské jméno a `1q2w3E*` jako heslo k přihlášení do aplikace.
+
+Startovací šabloná obsahuje **identity management** a **tenant management** moduly. Jakmile se přihlásite, budete mít přístup do nabídky Administrace, kde můžete spravovat **tenanty**, **role**, **uživatele** a jejich **oprávnění**. Správa uživatelů vypadá takto:
+
+![bookstore-user-management](images/bookstore-user-management-v2.png)
+
+### Co dále?
+
+* [Tutoriál vývoje aplikace](Tutorials/AspNetCore-Mvc/Part-I.md)

docs/cs/Getting-Started-Console-Application.md

@@ -0,0 +1,181 @@
+# Začínáme s konzolovou aplikací
+
+Tento tutoriál vysvětluje jak začít s ABP z ničeho s minimem závislostí. Obvykle chcete začít se **[startovací šablonou](https://abp.io/Templates)**.
+
+## Tvorba nového projektu
+
+Vytvořte regulérní .NET Core konzolovou aplikaci z Visual Studio:
+
+![](images/create-new-net-core-console-application.png)
+
+## Instalace Volo.Abp balíku
+
+Volo.Abp.Core je základní NuGet balík k tvorbě aplikací založených na ABP. Takže ho nainstalujeme do projektu:
+
+````
+Install-Package Volo.Abp.Core
+````
+
+## Tvorba prvního ABP modulu
+
+ABP je modulární framework a proto vyžaduje **spouštěcí (kořenový) modul** což je třída dědící z ``AbpModule``:
+
+````C#
+using Microsoft.Extensions.DependencyInjection;
+using Volo.Abp.Modularity;
+
+namespace AbpConsoleDemo
+{
+    public class AppModule : AbpModule
+    {
+        
+    }
+}
+````
+
+``AppModule`` je dobrý název pro spouštěcí modul aplikace.
+
+## Inicializace aplikace
+
+Dalším krokem je bootstrap aplikace pomocí spouštěcího modulu vytvořeného výše:
+
+````C#
+using System;
+using Volo.Abp;
+
+namespace AbpConsoleDemo
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            using (var application = AbpApplicationFactory.Create<AppModule>())
+            {
+                application.Initialize();
+
+                Console.WriteLine("Press ENTER to stop application...");
+                Console.ReadLine();
+            }
+        }
+    }
+}
+
+````
+
+``AbpApplicationFactory`` se používá k vytvoření aplikace a načtení všech modulů, s využitím ``AppModule`` jako spouštěcím modulem. ``Initialize()`` metoda spouští aplikaci.
+
+## Ahoj světe!
+
+Aplikace výše zatím nic nedělá. Pojďme proto vytvořit službu která už něco dělá:
+
+````C#
+using System;
+using Volo.Abp.DependencyInjection;
+
+namespace AbpConsoleDemo
+{
+    public class HelloWorldService : ITransientDependency
+    {
+        public void SayHello()
+        {
+            Console.WriteLine("Hello World!");
+        }
+    }
+}
+
+````
+
+``ITransientDependency`` je speciální rozhraní ABP, které automaticky registruje službu jako přechodnou (více v [dokumentu vkládání závislostí](Dependency-Injection.md)).
+
+Nyní můžeme vyřešit ``HelloWorldService`` a vypsat naše ahoj. Změníme Program.cs podle vyobrazení níže:
+
+````C#
+using System;
+using Microsoft.Extensions.DependencyInjection;
+using Volo.Abp;
+
+namespace AbpConsoleDemo
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            using (var application = AbpApplicationFactory.Create<AppModule>())
+            {
+                application.Initialize();
+
+                // Vyřeší službu a použije ji
+                var helloWorldService = 
+                    application.ServiceProvider.GetService<HelloWorldService>();
+                helloWorldService.SayHello();
+
+                Console.WriteLine("Press ENTER to stop application...");
+                Console.ReadLine();
+            }
+        }
+    }
+}
+````
+
+I když je to dostačující pro tento jednoduchý príklad kódu, je vždy lepší v případě přímého řešení závislostí z ``IServiceProvider`` vytvořit rámce (více v [dokumentu vkládání závislostí](Dependency-Injection.md)).
+
+## Využití Autofac jako frameworku pro vkládání závislostí
+
+Ačkoliv je AspNet Core systém pro vkládání závíslostí (DI) skvělý pro základní požadavky, Autofac poskytuje pokročilé funkce jako injekce vlastností nebo záchyt metod, které jsou v ABP užity k provádění pokročilých funkcí frameworku.
+
+Nahrazení AspNet Core DI systému za Autofac a integrace s ABP je snadná.
+
+1. Nainstalujeme [Volo.Abp.Autofac](https://www.nuget.org/packages/Volo.Abp.Autofac) balík
+
+```
+Install-Package Volo.Abp.Autofac
+```
+
+1. Přidáme ``AbpAutofacModule`` závislost
+
+```c#
+[DependsOn(typeof(AbpAutofacModule))] // Přidá závislost na AbpAutofacModule
+public class AppModule : AbpModule
+{
+    
+}
+```
+
+1. Změníme soubor ``Program.cs`` podle vyobrazení níže:
+
+```c#
+using System;
+using Microsoft.Extensions.DependencyInjection;
+using Volo.Abp;
+
+namespace AbpConsoleDemo
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            using (var application = AbpApplicationFactory.Create<AppModule>(options =>
+            {
+                options.UseAutofac(); // Autofac integrace
+            }))
+            {
+                application.Initialize();
+
+                // Vyřeší službu a použije ji
+                var helloWorldService = 
+                    application.ServiceProvider.GetService<HelloWorldService>();
+                helloWorldService.SayHello();
+
+                Console.WriteLine("Press ENTER to stop application...");
+                Console.ReadLine();
+            }
+        }
+    }
+}
+```
+
+Stačí volat metodu `options.UseAutofac()` v možnostech `AbpApplicationFactory.Create`.
+
+## Zdrojový kód
+
+Získejte zdrojový kód vzorového projektu vytvořeného v tomto tutoriálů [z tohoto odkazu](https://github.com/abpframework/abp/tree/master/samples/BasicConsoleApplication).