# Getting Started ABP With AspNet Core MVC Web Application
# Začínáme s ASP.NET Core MVC aplikací
This tutorial explains how to start ABP from scratch with minimal dependencies. You generally want to start with the **[startup template](Getting-Started-AspNetCore-MVC-Template.md)**.
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)**.
## Create A New Project
## Tvorba nového projektu
1. Create a new empty AspNet Core Web Application from Visual Studio:
1. Vytvořte novou prázdnou AspNet Core Web aplikaci ve Visual Studio:
``AppModule`` is a good name for the startup module for an application.
``AppModule`` je dobrý název pro spouštěcí modul aplikace.
ABP packages define module classes and a module can depend on another module. In the code above, our ``AppModule`` depends on ``AbpAspNetCoreMvcModule`` (defined by Volo.Abp.AspNetCore.Mvc package). It's common to add a ``DependsOn`` attribute after installing a new ABP nuget package.
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.
Instead of Startup class, we are configuring ASP.NET Core pipeline in this module class.
Místo třídy Startup, konfigurujeme ASP.NET Core pipeline v této modulové třídě.
## The Startup Class
## Třída Startup
Next step is to modify Startup class to integrate to ABP module system:
V dalším kroku upravíme Startup třídu k integraci ABP modulového systému:
Changed ``ConfigureServices`` method to return ``IServiceProvider`` instead of ``void``. This change allows us to replace AspNet Core's Dependency Injection with another framework (see Autofac integration section below). ``services.AddApplication<AppModule>()`` adds all services defined in all modules beginning from the ``AppModule``.
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``.
``app.InitializeApplication()`` call in ``Configure`` method initializes and starts the application.
Volání ``app.InitializeApplication()`` v metodě ``Configure`` inicializuje a spustí aplikaci.
## Hello World!
## Ahoj světe!
The application above does nothing. Let's create an MVC controller does something:
Aplikace výše zatím nic nedělá. Pojďme proto vytvořit MVC controller, který už něco dělá:
If you run the application, you will see a "Hello World!" message on the page.
Jakmile spustíte aplikaci, uvidíte na stránce zprávu "Hello World!".
Derived ``HomeController`` from ``AbpController`` instead of standard ``Controller`` class. This is not required, but ``AbpController`` class has useful base properties and methods to make your development easier.
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.
## Using Autofac as the Dependency Injection Framework
## Použití Autofac jako frameworku pro vkládání závislostí
While AspNet Core's Dependency Injection (DI) system is fine for basic requirements, Autofac provides advanced features like Property Injection and Method Interception which are required by ABP to perform advanced application framework features.
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.
Replacing AspNet Core's DI system by Autofac and integrating to ABP is pretty easy.
Nahrazení AspNet Core DI systému za Autofac a integrace s ABP je snadná.
[DependsOn(typeof(AbpAutofacModule))] //Add dependency to ABP Autofac module
[DependsOn(typeof(AbpAutofacModule))] // Přidá závislost na AbpAutofacModule
public class AppModule : AbpModule
{
...
}
````
3. Change ``services.AddApplication<AppModule>();`` line in the ``Startup`` class as shown below:
3. Změníme řádek ``services.AddApplication<AppModule>();`` v třídě ``Startup`` následovně:
````C#
services.AddApplication<AppModule>(options =>
{
options.UseAutofac(); //Integrate to Autofac
options.UseAutofac(); // Integrace s Autofac
});
````
4. Update `Program.cs` to not use the `WebHost.CreateDefaultBuilder()` method since it uses the default DI container:
4. Upravíme `Program.cs` aby nepoužíval metodu `WebHost.CreateDefaultBuilder()` jelikož ta používá výchozí DI kontejner:
````csharp
public class Program
@ -180,7 +180,7 @@ public class Program
}
````
## Source Code
## Zdrojový kód
Get source code of the sample project created in this tutorial from [here](https://github.com/abpframework/abp/tree/master/samples/BasicAspNetCoreApplication).
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).
## Getting Started With the ASP.NET Core MVC Template
## Začínáme s ASP.NET Core MVC šablonou
This tutorials explains how to create a new ASP.NET Core MVC web application using the startup template, configure and run it.
Tento tutoriál vysvětluje, jak vytvořit novou ASP.NET Core MVC webovou aplikaci pomocí úvodní šablony, jak ji nakonfigurovat a spustit.
### Creating a New Project
### Tvorba nového projektu
This tutorial uses **ABP CLI** to create a new project. See the [Get Started](https://abp.io/get-started) page for other options.
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í.
Install the ABP CLI using a command line window, if you've not installed before:
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
````
Use `abp new` command in an empty folder to create your project:
K tvorbě vašeho projektu použijte příkaz `abp new` v prázdné složce:
````bash
abp new Acme.BookStore
````
> You can use different level of namespaces; e.g. BookStore, Acme.BookStore or Acme.Retail.BookStore.
> Můžete použít různé úrovně jmenných prostorů; např. BookStore, Acme.BookStore nebo Acme.Retail.BookStore.
`new` command creates a **layered MVC application** with **Entity Framework Core** as the database provider. However, it has additional options. See the [CLI documentation](CLI.md) for all available options.
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í.
#### Pre Requirements
#### Požadavky
The created solution requires;
Vytvořené řešení vyžaduje;
* [Visual Studio 2017 (v15.9.0+)](https://visualstudio.microsoft.com/tr/downloads/)
The solution has a layered structure (based on [Domain Driven Design](Domain-Driven-Design.md)) and contains unit & integration test projects properly configured to work with **EF Core**&**SQLite in-memory** database.
Ř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í.
> See [MVC application template document](Startup-Templates/Mvc.md) to understand the solution structure in details.
> Podívejte se na [dokument šablony MVC aplikace](Startup-Templates/Mvc.md) k detailnímu pochopení struktury řešení.
### Database Connection String
### Connection string databáze
Check the **connection string** in the `appsettings.json` file under the `.Web` project:
Zkontrolujte **connection string** v souboru `appsettings.json` v projektu `.Web`:
````json
{
@ -51,52 +51,52 @@ Check the **connection string** in the `appsettings.json` file under the `.Web`
}
````
The solution is configured to use **Entity Framework Core** with **MS SQL Server**. EF Core supports [various](https://docs.microsoft.com/en-us/ef/core/providers/) database providers, so you can use another DBMS if you want. Change the connection string if you need.
Ř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.
### Create Database & Apply Database Migrations
### Tvorba databáze & aplikace databázových migrací
You have two options to create the database.
K vytvoření databáze máte dvě možnosti.
#### Using the DbMigrator Application
#### Použití DbMigrator aplikace
The solution contains a console application (named `Acme.BookStore.DbMigrator` in this sample) that can create database, apply migrations and seed initial data. It is useful on development as well as on production environment.
Ř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í.
> `.DbMigrator` project has its own `appsettings.json`. So, if you have changed the connection string above, you should also change this one.
> Projekt `.DbMigrator` má vlastní `appsettings.json`. Takže pokud jste změnili connection string uvedený výše, musíte změnit také tento.
Right click to the `.DbMigrator` project and select**Set as StartUp Project**:
Klikněte pravým na projekt `.DbMigrator` a vyberte**Set as StartUp Project**:
Ef Core has `Update-Database` command which creates database if necessary and applies pending migrations. Right click to the `.Web` project and select**Set as StartUp Project**:
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**:
Open the **Package Manager Console**, select `.EntityFrameworkCore.DbMigrations` project as the **Default Project** and run the `Update-Database` command:
Otevřete **Package Manager Console**, vyberte projekt `.EntityFrameworkCore.DbMigrations` jako **Default Project** and spusťte příkaz `Update-Database`:
Click the **Login** button, enter `admin` as the username and `1q2w3E*` as the password to login to the application.
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.
The startup template includes the **identity management** and **tenant management** modules. Once you login, the Administration menu will be available where you can manage **tenants**, **roles**, **users** and their **permissions**. User management page is shown below:
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:
This tutorial explains how to start ABP from scratch with minimal dependencies. You generally want to start with a **[startup template](https://abp.io/Templates)**.
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)**.
## Create A New Project
## Tvorba nového projektu
Create a new Regular .Net Core Console Application from Visual Studio:
Vytvořte regulérní .NET Core konzolovou aplikaci z Visual Studio:
Volo.Abp.Core is the core nuget package to create ABP based applications. So, install it to your project:
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
````
## Create First ABP Module
## Tvorba prvního ABP modulu
ABP is a modular framework and it requires a **startup (root) module** class derived from ``AbpModule``:
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;
@ -33,11 +33,11 @@ namespace AbpConsoleDemo
}
````
``AppModule`` is a good name for the startup module for an application.
``AppModule`` je dobrý název pro spouštěcí modul aplikace.
## Initialize The Application
## Inicializace aplikace
The next step is to bootstrap the application using the startup module created above:
Dalším krokem je bootstrap aplikace pomocí spouštěcího modulu vytvořeného výše:
````C#
using System;
@ -62,11 +62,11 @@ namespace AbpConsoleDemo
````
``AbpApplicationFactory`` is used to create the application and load all modules taking ``AppModule`` as the startup module. ``Initialize()`` method starts the application.
``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.
## Hello World!
## Ahoj světe!
The application above does nothing. Let's create a service that does something:
Aplikace výše zatím nic nedělá. Pojďme proto vytvořit službu která už něco dělá:
````C#
using System;
@ -85,9 +85,9 @@ namespace AbpConsoleDemo
````
``ITransientDependency`` is a special interface of ABP that automatically registers the service as transient (see [dependency injection document](Dependency-Injection.md)).
``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)).
Now, we can resolve the ``HelloWorldService`` and say hello. Change the Program.cs as shown below:
Nyní můžeme vyřešit ``HelloWorldService`` a vypsat naše ahoj. Změníme Program.cs podle vyobrazení níže:
While it's enough for this simple code example, it's always suggested to create scopes in case of directly resolving dependencies from ``IServiceProvider`` (see the [Dependency Injection documentation](Dependency-Injection.md)).
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)).
## Using Autofac as the Dependency Injection Framework
## Využití Autofac jako frameworku pro vkládání závislostí
While AspNet Core's Dependency Injection (DI) system is fine for basic requirements, Autofac provides advanced features like Property Injection and Method Interception which are required by ABP to perform advanced application framework features.
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.
Replacing AspNet Core's DI system by Autofac and integrating to ABP is pretty easy.
Nahrazení AspNet Core DI systému za Autofac a integrace s ABP je snadná.
Just called `options.UseAutofac()` method in the `AbpApplicationFactory.Create` options.
Stačí volat metodu `options.UseAutofac()` v možnostech `AbpApplicationFactory.Create`.
## Source Code
## Zdrojový kód
Get source code of the sample project created in this tutorial from [here](https://github.com/abpframework/abp/tree/master/samples/BasicConsoleApplication).
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).
Xeevis
6 years ago