mirror of https://github.com/abpframework/abp.git
selman koc
2 years ago
committed by
GitHub
GitHub
1881 changed files with 32933 additions and 62227 deletions
@ -1,165 +1,89 @@ |
|||
GNU LESSER GENERAL PUBLIC LICENSE |
|||
Version 3, 29 June 2007 |
|||
|
|||
Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/> |
|||
Everyone is permitted to copy and distribute verbatim copies |
|||
of this license document, but changing it is not allowed. |
|||
Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/> |
|||
Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. |
|||
|
|||
This version of the GNU Lesser General Public License incorporates the terms and conditions of version 3 of the GNU General Public. |
|||
The license is supplemented by the additional permissions listed below. |
|||
|
|||
This version of the GNU Lesser General Public License incorporates |
|||
the terms and conditions of version 3 of the GNU General Public |
|||
License, supplemented by the additional permissions listed below. |
|||
|
|||
0. Additional Definitions. |
|||
|
|||
As used herein, "this License" refers to version 3 of the GNU Lesser |
|||
General Public License, and the "GNU GPL" refers to version 3 of the GNU |
|||
General Public License. |
|||
**0. Additional Definitions.** |
|||
|
|||
As used herein, "this License" refers to version 3 of the GNU Lesser General Public License, and the "GNU GPL" refers to version 3 of the GNU General Public License. |
|||
|
|||
"The Library" refers to a covered work governed by this License, other than an Application or a Combined Work as defined below. |
|||
|
|||
An "Application" is any work that makes use of an interface provided by the Library but which is not otherwise based on the Library. Defining a subclass of a class defined by the Library is deemed a mode of using an interface provided by the Library. |
|||
|
|||
A "Combined Work" is a work produced by combining or linking an Application with the Library. The particular version of the Library with which the Combined Work was made is also called the "Linked Version". |
|||
|
|||
The "Minimal Corresponding Source" for a Combined Work means the Corresponding Source for the Combined Work, excluding any source code for portions of the Combined Work that, considered in isolation, are based on the Application and not on the Linked Version. |
|||
|
|||
The "Corresponding Application Code" for a Combined Work means the object code and/or source code for the Application, including any data and utility programs needed for reproducing the Combined Work from the Application, but excluding the System Libraries of the Combined Work. |
|||
|
|||
|
|||
|
|||
**1. Exception to Section 3 of the GNU GPL.** |
|||
|
|||
You may convey a covered work under sections 3 and 4 of this License without being bound by section 3 of the GNU GPL. |
|||
|
|||
|
|||
|
|||
**2. Conveying Modified Versions.** |
|||
|
|||
If you modify a copy of the Library and, in your modifications, a facility refers to a function or data to be supplied by an Application that uses the facility (other than as an argument passed when the facility is invoked), then you may convey a copy of the modified version: |
|||
|
|||
**a)** under this License, provided that you make a good-faith effort to ensure that, in the event an Application does not supply the |
|||
function or data, the facility still operates and performs whatever part of its purpose remains meaningful, or |
|||
|
|||
**b)** under the GNU GPL, with none of the additional permissions of this License is applicable to that copy. |
|||
|
|||
|
|||
|
|||
**3. Object Code Incorporating Material from Library Header Files.** |
|||
|
|||
The object code form of an Application may incorporate material from a header file that is part of the Library. You may convey such an object code under terms of your choice, provided that if the incorporated material is not limited to numerical parameters, data structure layouts and accessors, or small macros, inline functions and templates (ten or fewer lines in length), you do both of the following: |
|||
|
|||
**a)** Give prominent notice with each copy of the object code that the Library is used in it, and the Library and its use are covered by this License. |
|||
|
|||
**b)** Accompany the object code with a copy of the GNU GPL and this license document. |
|||
|
|||
|
|||
|
|||
**4. Combined Works.** |
|||
|
|||
You may convey a Combined Work under terms of your choice that, taken together, effectively do not restrict modification of the portions of the Library contained in the Combined Work and reverse engineering for debugging such modifications, if you also do each of the following: |
|||
|
|||
**a)** Give prominent notice with each copy of the Combined Work that the Library is used in it and that the Library and its use are covered by this License. |
|||
|
|||
**b)** Accompany the Combined Work with a copy of the GNU GPL and this license document. |
|||
|
|||
**c)** For a Combined Work that displays copyright notices during execution, including the copyright notice for the Library among these notices, as well as a reference directing the user to the copies of the GNU GPL and this license document. |
|||
|
|||
**d)** Do one of the following: |
|||
|
|||
0) Convey the Minimal Corresponding Source under the terms of this License and the Corresponding Application Code in a form suitable for, and under terms that permit, the user to recombine or relink the Application with a modified version of the Linked Version to produce a modified Combined Work in the manner specified by section 6 of the GNU GPL for conveying Corresponding Source. |
|||
1) Use a suitable shared library mechanism for linking with the Library. A suitable mechanism is one that (a) uses at run time a copy of the Library already present on the user's computer system and (b) will operate properly with a modified version of the Library that is interface-compatible with the Linked Version. |
|||
|
|||
**e)** Provide Installation Information, but only if you would otherwise be required to provide such information under section 6 of the GNU GPL, and only to the extent that such information is necessary to install and execute a modified version of the Combined Work produced by recombining or relinking the Application with a modified version of the Linked Version. (If you use option 4d0, the Installation Information must accompany the Minimal Corresponding Source and Corresponding Application Code. If you use option 4d1, you must provide the Installation Information in the manner specified by section 6 of the GNU GPL for conveying the Corresponding Source.) |
|||
|
|||
|
|||
"The Library" refers to a covered work governed by this License, |
|||
other than an Application or a Combined Work as defined below. |
|||
|
|||
An "Application" is any work that makes use of an interface provided |
|||
by the Library, but which is not otherwise based on the Library. |
|||
Defining a subclass of a class defined by the Library is deemed a mode |
|||
of using an interface provided by the Library. |
|||
|
|||
A "Combined Work" is a work produced by combining or linking an |
|||
Application with the Library. The particular version of the Library |
|||
with which the Combined Work was made is also called the "Linked |
|||
Version". |
|||
|
|||
The "Minimal Corresponding Source" for a Combined Work means the |
|||
Corresponding Source for the Combined Work, excluding any source code |
|||
for portions of the Combined Work that, considered in isolation, are |
|||
based on the Application, and not on the Linked Version. |
|||
|
|||
The "Corresponding Application Code" for a Combined Work means the |
|||
object code and/or source code for the Application, including any data |
|||
and utility programs needed for reproducing the Combined Work from the |
|||
Application, but excluding the System Libraries of the Combined Work. |
|||
|
|||
1. Exception to Section 3 of the GNU GPL. |
|||
|
|||
You may convey a covered work under sections 3 and 4 of this License |
|||
without being bound by section 3 of the GNU GPL. |
|||
|
|||
2. Conveying Modified Versions. |
|||
|
|||
If you modify a copy of the Library, and, in your modifications, a |
|||
facility refers to a function or data to be supplied by an Application |
|||
that uses the facility (other than as an argument passed when the |
|||
facility is invoked), then you may convey a copy of the modified |
|||
version: |
|||
|
|||
a) under this License, provided that you make a good faith effort to |
|||
ensure that, in the event an Application does not supply the |
|||
function or data, the facility still operates, and performs |
|||
whatever part of its purpose remains meaningful, or |
|||
|
|||
b) under the GNU GPL, with none of the additional permissions of |
|||
this License applicable to that copy. |
|||
|
|||
3. Object Code Incorporating Material from Library Header Files. |
|||
|
|||
The object code form of an Application may incorporate material from |
|||
a header file that is part of the Library. You may convey such object |
|||
code under terms of your choice, provided that, if the incorporated |
|||
material is not limited to numerical parameters, data structure |
|||
layouts and accessors, or small macros, inline functions and templates |
|||
(ten or fewer lines in length), you do both of the following: |
|||
|
|||
a) Give prominent notice with each copy of the object code that the |
|||
Library is used in it and that the Library and its use are |
|||
covered by this License. |
|||
|
|||
b) Accompany the object code with a copy of the GNU GPL and this license |
|||
document. |
|||
|
|||
4. Combined Works. |
|||
|
|||
You may convey a Combined Work under terms of your choice that, |
|||
taken together, effectively do not restrict modification of the |
|||
portions of the Library contained in the Combined Work and reverse |
|||
engineering for debugging such modifications, if you also do each of |
|||
the following: |
|||
|
|||
a) Give prominent notice with each copy of the Combined Work that |
|||
the Library is used in it and that the Library and its use are |
|||
covered by this License. |
|||
|
|||
b) Accompany the Combined Work with a copy of the GNU GPL and this license |
|||
document. |
|||
|
|||
c) For a Combined Work that displays copyright notices during |
|||
execution, include the copyright notice for the Library among |
|||
these notices, as well as a reference directing the user to the |
|||
copies of the GNU GPL and this license document. |
|||
|
|||
d) Do one of the following: |
|||
|
|||
0) Convey the Minimal Corresponding Source under the terms of this |
|||
License, and the Corresponding Application Code in a form |
|||
suitable for, and under terms that permit, the user to |
|||
recombine or relink the Application with a modified version of |
|||
the Linked Version to produce a modified Combined Work, in the |
|||
manner specified by section 6 of the GNU GPL for conveying |
|||
Corresponding Source. |
|||
|
|||
1) Use a suitable shared library mechanism for linking with the |
|||
Library. A suitable mechanism is one that (a) uses at run time |
|||
a copy of the Library already present on the user's computer |
|||
system, and (b) will operate properly with a modified version |
|||
of the Library that is interface-compatible with the Linked |
|||
Version. |
|||
|
|||
e) Provide Installation Information, but only if you would otherwise |
|||
be required to provide such information under section 6 of the |
|||
GNU GPL, and only to the extent that such information is |
|||
necessary to install and execute a modified version of the |
|||
Combined Work produced by recombining or relinking the |
|||
Application with a modified version of the Linked Version. (If |
|||
you use option 4d0, the Installation Information must accompany |
|||
the Minimal Corresponding Source and Corresponding Application |
|||
Code. If you use option 4d1, you must provide the Installation |
|||
Information in the manner specified by section 6 of the GNU GPL |
|||
for conveying Corresponding Source.) |
|||
|
|||
5. Combined Libraries. |
|||
|
|||
You may place library facilities that are a work based on the |
|||
Library side by side in a single library together with other library |
|||
facilities that are not Applications and are not covered by this |
|||
License, and convey such a combined library under terms of your |
|||
choice, if you do both of the following: |
|||
|
|||
a) Accompany the combined library with a copy of the same work based |
|||
on the Library, uncombined with any other library facilities, |
|||
conveyed under the terms of this License. |
|||
|
|||
b) Give prominent notice with the combined library that part of it |
|||
is a work based on the Library, and explaining where to find the |
|||
accompanying uncombined form of the same work. |
|||
|
|||
6. Revised Versions of the GNU Lesser General Public License. |
|||
|
|||
The Free Software Foundation may publish revised and/or new versions |
|||
of the GNU Lesser General Public License from time to time. Such new |
|||
versions will be similar in spirit to the present version, but may |
|||
differ in detail to address new problems or concerns. |
|||
|
|||
Each version is given a distinguishing version number. If the |
|||
Library as you received it specifies that a certain numbered version |
|||
of the GNU Lesser General Public License "or any later version" |
|||
applies to it, you have the option of following the terms and |
|||
conditions either of that published version or of any later version |
|||
published by the Free Software Foundation. If the Library as you |
|||
received it does not specify a version number of the GNU Lesser |
|||
General Public License, you may choose any version of the GNU Lesser |
|||
General Public License ever published by the Free Software Foundation. |
|||
|
|||
If the Library as you received it specifies that a proxy can decide |
|||
whether future versions of the GNU Lesser General Public License shall |
|||
apply, that proxy's public statement of acceptance of any version is |
|||
permanent authorization for you to choose that version for the |
|||
Library. |
|||
You may place library facilities that are work based on the Library side by side in a single library together with other library facilities that are not Applications and are not covered by this License and convey such a combined library under the terms of your choice if you do both of the following: |
|||
|
|||
**a)** Accompany the combined library with a copy of the same work based on the Library, uncombined with any other library facilities, conveyed under the terms of this License. |
|||
|
|||
**b)** Give prominent notice with the combined library that part of it is a work based on the Library and explains where to find the accompanying uncombined form of the same work. |
|||
|
|||
|
|||
|
|||
**6. Revised Versions of the GNU Lesser General Public License.** |
|||
|
|||
The Free Software Foundation may publish revised and/or new versions of the GNU Lesser General Public License from time to time. Such new versions will be similar in spirit to the present version but may differ in detail to address new problems or concerns. |
|||
|
|||
Each version is given a distinguishing version number. If the Library as you received it specifies that a certain numbered version of the GNU Lesser General Public License "or any later version" applies to it, you have the option of following the terms and conditions either of that published version or of any later version published by the Free Software Foundation. If the Library as you received, it does not specify a version number of the GNU Lesser |
|||
General Public License, you may choose any version of the GNU Lesser General Public License ever published by the Free Software Foundation. If the Library as you received it specifies that a proxy can decide whether future versions of the GNU Lesser General Public License shall apply, that proxy's public statement of acceptance of any version is permanent authorization for you to choose that version for the Library. |
|||
|
|||
@ -1,506 +0,0 @@ |
|||
# Widgety |
|||
|
|||
ABP poskytuje model a infastrukturu k vytváření **znovu použitelných widgetů**. Systém widgetů je rozšíření pro [ASP.NET Core pohledové komponenty](https://docs.microsoft.com/en-us/aspnet/core/mvc/views/view-components). Widgety jsou zvláště užitečné, když chcete; |
|||
|
|||
* Mít závislosti na **skriptech & stylech** ve vašem widgetu. |
|||
* Vytvářet **řídící panely** za použítí widgetů. |
|||
* Definovat widgety v znovu použitelných **[modulech](../Module-Development-Basics.md)**. |
|||
* Spolupráci widgetů s **[authorizačními](../Authorization.md)** a **[svazovacími](Bundling-Minification.md)** systémy. |
|||
|
|||
## Základní definice widgetu |
|||
|
|||
### Tvorba pohledové komponenty |
|||
|
|||
Jako první krok, vytvořte běžnou ASP.NET Core pohledovou komponentu: |
|||
|
|||
 |
|||
|
|||
**MySimpleWidgetViewComponent.cs**: |
|||
|
|||
````csharp |
|||
using Microsoft.AspNetCore.Mvc; |
|||
using Volo.Abp.AspNetCore.Mvc; |
|||
|
|||
namespace DashboardDemo.Web.Pages.Components.MySimpleWidget |
|||
{ |
|||
public class MySimpleWidgetViewComponent : AbpViewComponent |
|||
{ |
|||
public IViewComponentResult Invoke() |
|||
{ |
|||
return View(); |
|||
} |
|||
} |
|||
} |
|||
```` |
|||
|
|||
Dědění z `AbpViewComponent` není vyžadováno. Můžete dědit ze standardního ASP.NET Core `ViewComponent`. `AbpViewComponent` pouze definuje pár základních a užitečných vlastnosti. |
|||
|
|||
Můžete vložit službu a pomocí metody `Invoke` z ní získat některá data. Možná budete muset provést metodu Invoke jako asynchronní `public async Task<IViewComponentResult> InvokeAsync()`. Podívejte se na dokument [ASP.NET Core ViewComponents](https://docs.microsoft.com/en-us/aspnet/core/mvc/views/view-components) pro všechna další použítí. |
|||
|
|||
**Default.cshtml**: |
|||
|
|||
```xml |
|||
<div class="my-simple-widget"> |
|||
<h2>My Simple Widget</h2> |
|||
<p>This is a simple widget!</p> |
|||
</div> |
|||
``` |
|||
|
|||
### Definice widgetu |
|||
|
|||
Přidejte atribut `Widget` k třídě `MySimpleWidgetViewComponent` pro označení této pohledové komponenty jako widgetu: |
|||
|
|||
````csharp |
|||
using Microsoft.AspNetCore.Mvc; |
|||
using Volo.Abp.AspNetCore.Mvc; |
|||
using Volo.Abp.AspNetCore.Mvc.UI.Widgets; |
|||
|
|||
namespace DashboardDemo.Web.Pages.Components.MySimpleWidget |
|||
{ |
|||
[Widget] |
|||
public class MySimpleWidgetViewComponent : AbpViewComponent |
|||
{ |
|||
public IViewComponentResult Invoke() |
|||
{ |
|||
return View(); |
|||
} |
|||
} |
|||
} |
|||
```` |
|||
|
|||
## Vykreslení widgetu |
|||
|
|||
Vykreslení widgetu je vcelku standardní. Použijte metodu `Component.InvokeAsync` v razor pohledu/stránce jako s kteroukoliv jinou pohledovou komponentou. Příklady: |
|||
|
|||
````xml |
|||
@await Component.InvokeAsync("MySimpleWidget") |
|||
@await Component.InvokeAsync(typeof(MySimpleWidgetViewComponent)) |
|||
```` |
|||
|
|||
První přístup používá název widgetu, zatímco druhý používá typ pohledové komponenty. |
|||
|
|||
### Widgety s argumenty |
|||
|
|||
Systém ASP.NET Core pohledových komponent umožňuje přijímat argumenty pro pohledové komponenty. Níže uvedená pohledová komponenta přijímá `startDate` a `endDate` a používá tyto argumenty k získání dat ze služby. |
|||
|
|||
````csharp |
|||
using System; |
|||
using System.Threading.Tasks; |
|||
using Microsoft.AspNetCore.Mvc; |
|||
using Volo.Abp.AspNetCore.Mvc; |
|||
using Volo.Abp.AspNetCore.Mvc.UI.Widgets; |
|||
|
|||
namespace DashboardDemo.Web.Pages.Shared.Components.CountersWidget |
|||
{ |
|||
[Widget] |
|||
public class CountersWidgetViewComponent : AbpViewComponent |
|||
{ |
|||
private readonly IDashboardAppService _dashboardAppService; |
|||
|
|||
public CountersWidgetViewComponent(IDashboardAppService dashboardAppService) |
|||
{ |
|||
_dashboardAppService = dashboardAppService; |
|||
} |
|||
|
|||
public async Task<IViewComponentResult> InvokeAsync( |
|||
DateTime startDate, DateTime endDate) |
|||
{ |
|||
var result = await _dashboardAppService.GetCountersWidgetAsync( |
|||
new CountersWidgetInputDto |
|||
{ |
|||
StartDate = startDate, |
|||
EndDate = endDate |
|||
} |
|||
); |
|||
|
|||
return View(result); |
|||
} |
|||
} |
|||
} |
|||
```` |
|||
|
|||
Nyní musíte předat anonymní objekt k předání argumentů tak jak je ukázáno níže: |
|||
|
|||
````xml |
|||
@await Component.InvokeAsync("CountersWidget", new |
|||
{ |
|||
startDate = DateTime.Now.Subtract(TimeSpan.FromDays(7)), |
|||
endDate = DateTime.Now |
|||
}) |
|||
```` |
|||
|
|||
## Název widgetu |
|||
|
|||
Výchozí název pohledových komponent je vypočítán na základě názvu typu pohledové komponenty. Pokud je typ pohledové komponenty `MySimpleWidgetViewComponent` potom název widgetu bude `MySimpleWidget` (odstraní se `ViewComponent` postfix). Takto ASP.NET Core vypočítává název pohledové komponenty. |
|||
|
|||
Chcete-li přizpůsobit název widgetu, stačí použít standardní atribut `ViewComponent` z ASP.NET Core: |
|||
|
|||
```csharp |
|||
using Microsoft.AspNetCore.Mvc; |
|||
using Volo.Abp.AspNetCore.Mvc; |
|||
using Volo.Abp.AspNetCore.Mvc.UI.Widgets; |
|||
|
|||
namespace DashboardDemo.Web.Pages.Components.MySimpleWidget |
|||
{ |
|||
[Widget] |
|||
[ViewComponent(Name = "MyCustomNamedWidget")] |
|||
public class MySimpleWidgetViewComponent : AbpViewComponent |
|||
{ |
|||
public IViewComponentResult Invoke() |
|||
{ |
|||
return View("~/Pages/Components/MySimpleWidget/Default.cshtml"); |
|||
} |
|||
} |
|||
} |
|||
``` |
|||
|
|||
ABP bude respektovat přizpůsobený název při zpracování widgetu. |
|||
|
|||
> Pokud jsou názvy pohledové komponenty a složky, která pohledovou komponentu obsahuje rozdílné, pravděpodobně budete muset ručně uvést cestu pohledu tak jako je to provedeno v tomto příkladu. |
|||
|
|||
### Zobrazovaný název |
|||
|
|||
Můžete také definovat čitelný & lokalizovatelný zobrazovaný název pro widget. Tento zobrazovaný název může být využít na uživatelském rozhraní kdykoliv je to potřeba. Zobrazovaný název je nepovinný a lze ho definovat pomocí vlastností atributu `Widget`: |
|||
|
|||
````csharp |
|||
using DashboardDemo.Localization; |
|||
using Microsoft.AspNetCore.Mvc; |
|||
using Volo.Abp.AspNetCore.Mvc; |
|||
using Volo.Abp.AspNetCore.Mvc.UI.Widgets; |
|||
|
|||
namespace DashboardDemo.Web.Pages.Components.MySimpleWidget |
|||
{ |
|||
[Widget( |
|||
DisplayName = "MySimpleWidgetDisplayName", // Lokalizační klíč |
|||
DisplayNameResource = typeof(DashboardDemoResource) // Lokalizační zdroj |
|||
)] |
|||
public class MySimpleWidgetViewComponent : AbpViewComponent |
|||
{ |
|||
public IViewComponentResult Invoke() |
|||
{ |
|||
return View(); |
|||
} |
|||
} |
|||
} |
|||
```` |
|||
|
|||
Podívejte se na [dokument lokalizace](../Localization.md) pro více informací o lokalizačních zdrojích a klíčích. |
|||
|
|||
## Závislosti na stylech & skriptech |
|||
|
|||
Problémy když má widget soubory skriptů a stylů; |
|||
|
|||
* Každý stránka, která používá widget musí také přidat soubory **skriptů & stylů** tohoto widgetu. |
|||
* Stránka se také musí postarat o **závislé knihovny/soubory** widgetu. |
|||
|
|||
ABP tyto problémy řeší, když správně propojíme zdroje s widgetem. O závislosti widgetu se při jeho používání nestaráme. |
|||
|
|||
### Definování jednoduchých cest souborů |
|||
|
|||
Níže uvedený příklad widgetu přidá stylové a skriptové soubory: |
|||
|
|||
````csharp |
|||
using Microsoft.AspNetCore.Mvc; |
|||
using Volo.Abp.AspNetCore.Mvc; |
|||
using Volo.Abp.AspNetCore.Mvc.UI.Widgets; |
|||
|
|||
namespace DashboardDemo.Web.Pages.Components.MySimpleWidget |
|||
{ |
|||
[Widget( |
|||
StyleFiles = new[] { "/Pages/Components/MySimpleWidget/Default.css" }, |
|||
ScriptFiles = new[] { "/Pages/Components/MySimpleWidget/Default.js" } |
|||
)] |
|||
public class MySimpleWidgetViewComponent : AbpViewComponent |
|||
{ |
|||
public IViewComponentResult Invoke() |
|||
{ |
|||
return View(); |
|||
} |
|||
} |
|||
} |
|||
```` |
|||
|
|||
ABP bere v úvahu tyto závislosti a správně je přidává do pohledu/stránky při použití widgetu. Stylové/skriptové soubory mohou být **fyzické nebo virtuální**. Plně integrováno do [virtuálního systému souborů](../Virtual-File-System.md). |
|||
|
|||
### Definování přispěvatelů balíku |
|||
|
|||
Všechny zdroje použité ve widgetech na stránce jsou přidány jako **svazek** (svázány & minifikovány v produkci pokud nenastavíte jinak). Kromě přidání jednoduchého souboru můžete využít plnou funkčnost přispěvatelů balíčků. |
|||
|
|||
Níže uvedený ukázkový kód provádí totéž co výše uvedený kód, ale definuje a používá přispěvatele balíků: |
|||
|
|||
````csharp |
|||
using System.Collections.Generic; |
|||
using Microsoft.AspNetCore.Mvc; |
|||
using Volo.Abp.AspNetCore.Mvc; |
|||
using Volo.Abp.AspNetCore.Mvc.UI.Bundling; |
|||
using Volo.Abp.AspNetCore.Mvc.UI.Widgets; |
|||
|
|||
namespace DashboardDemo.Web.Pages.Components.MySimpleWidget |
|||
{ |
|||
[Widget( |
|||
StyleTypes = new []{ typeof(MySimpleWidgetStyleBundleContributor) }, |
|||
ScriptTypes = new[]{ typeof(MySimpleWidgetScriptBundleContributor) } |
|||
)] |
|||
public class MySimpleWidgetViewComponent : AbpViewComponent |
|||
{ |
|||
public IViewComponentResult Invoke() |
|||
{ |
|||
return View(); |
|||
} |
|||
} |
|||
|
|||
public class MySimpleWidgetStyleBundleContributor : BundleContributor |
|||
{ |
|||
public override void ConfigureBundle(BundleConfigurationContext context) |
|||
{ |
|||
context.Files |
|||
.AddIfNotContains("/Pages/Components/MySimpleWidget/Default.css"); |
|||
} |
|||
} |
|||
|
|||
public class MySimpleWidgetScriptBundleContributor : BundleContributor |
|||
{ |
|||
public override void ConfigureBundle(BundleConfigurationContext context) |
|||
{ |
|||
context.Files |
|||
.AddIfNotContains("/Pages/Components/MySimpleWidget/Default.js"); |
|||
} |
|||
} |
|||
} |
|||
|
|||
```` |
|||
|
|||
Systém přispěvatelů balíků je velmi schopný. Pokud váš widget používá k vykreslení grafu JavaScript knihovnu, můžete ji deklarovat jako závislost, díky tomu se knihovna pokud nebyla dříve přidána automaticky přidá na stránku Tímto způsobem se stránka využívající váš widget nestará o závislosti. |
|||
|
|||
Podívejte se na dokumentaci [svazování & minifikace](Bundling-Minification.md) pro více informací o tomto systému. |
|||
|
|||
## RefreshUrl |
|||
|
|||
Widget může navrhnout `RefreshUrl`, který se používá vždy, když je potřeba widget aktualizovat. Je-li definován, widget se při každé aktualizaci znovu vykreslí na straně serveru (viz refresh `methoda` u `WidgetManager` níže). |
|||
|
|||
````csharp |
|||
[Widget(RefreshUrl = "Widgets/Counters")] |
|||
public class CountersWidgetViewComponent : AbpViewComponent |
|||
{ |
|||
|
|||
} |
|||
```` |
|||
|
|||
Jakmile pro svůj widget definujete `RefreshUrl`, musíte poskytnout koncový bod pro jeho vykreslení a vrátit ho: |
|||
|
|||
````csharp |
|||
[Route("Widgets")] |
|||
public class CountersWidgetController : AbpController |
|||
{ |
|||
[HttpGet] |
|||
[Route("Counters")] |
|||
public IActionResult Counters(DateTime startDate, DateTime endDate) |
|||
{ |
|||
return ViewComponent("CountersWidget", new {startDate, endDate}); |
|||
} |
|||
} |
|||
```` |
|||
|
|||
Trasa `Widgets/Counters` předchozímu `RefreshUrl`. |
|||
|
|||
> Widget lze obnovit dvěma způsoby: Prvním způsobem je použití `RefreshUrl`, kdy se znovu vykreslí na serveru a nahradí HTML vrácené tím ze serveru. Druhým způsobem widget získá data (obvykle JSON objekt) ze serveru a obnoví se sám u klienta (viz refresh metoda v sekci Widget JavaScript API). |
|||
|
|||
## JavaScript API |
|||
|
|||
Možná bude potřeba vykreslit a obnovit widget na straně klienta. V takových případech můžete použít ABP `WidgetManager` a definovat API pro vaše widgety. |
|||
|
|||
### WidgetManager |
|||
|
|||
`WidgetManager` se používá k inicializaci a aktualizaci jednoho nebo více widgetů. Vytvořte nový `WidgetManager` jako je ukázáno níže: |
|||
|
|||
````js |
|||
$(function() { |
|||
var myWidgetManager = new abp.WidgetManager('#MyDashboardWidgetsArea'); |
|||
}) |
|||
```` |
|||
|
|||
`MyDashboardWidgetsArea` může obsahovat jeden nebo více widgetů. |
|||
|
|||
> Použíti `WidgetManager` uvnitř document.ready (jako nahoře) je dobrá praktika jelikož jeho funkce používají DOM a potřebují, aby byl DOM připraven. |
|||
|
|||
#### WidgetManager.init() |
|||
|
|||
`init` jednoduše inicializuje `WidgetManager` a volá metody `init` v souvisejících widgetech pokud je obsahují (podívejte se na sekci Widget JavaScript API section níže) |
|||
|
|||
```js |
|||
myWidgetManager.init(); |
|||
``` |
|||
|
|||
#### WidgetManager.refresh() |
|||
|
|||
`refresh` metoda obnoví všechny widgety související s tímto `WidgetManager`: |
|||
|
|||
```` |
|||
myWidgetManager.refresh(); |
|||
```` |
|||
|
|||
#### WidgetManager možnosti |
|||
|
|||
WidgetManager má několik dalších možností. |
|||
|
|||
##### Filtrační formulář |
|||
|
|||
Pokud vaše widgety vyžadují parametry/filtry pak budete obvykle mít formulář pro filtrování widgetů. V takových případech můžete vytvořit formulář, který obsahuje prvky formuláře a oblast řídicího panelu s nějakými widgety uvnitř. Příklad: |
|||
|
|||
````xml |
|||
<form method="get" id="MyDashboardFilterForm"> |
|||
...prvky formuláře |
|||
</form> |
|||
|
|||
<div id="MyDashboardWidgetsArea" data-widget-filter="#MyDashboardFilterForm"> |
|||
...widgety |
|||
</div> |
|||
```` |
|||
|
|||
`data-widget-filter` atribut propojuje formulář s widgety. Kdykoli je formulář odeslán, všechny widgety jsou automaticky aktualizovány pomocí polí formuláře jako filtru. |
|||
|
|||
Místo atributu `data-widget-filter`, můžete použít parametr `filterForm` v konstruktoru `WidgetManager`. Příklad: |
|||
|
|||
````js |
|||
var myWidgetManager = new abp.WidgetManager({ |
|||
wrapper: '#MyDashboardWidgetsArea', |
|||
filterForm: '#MyDashboardFilterForm' |
|||
}); |
|||
```` |
|||
|
|||
##### Zpětné volání filtru |
|||
|
|||
Možná budete chtít mít lepší kontrolu nad poskytováním filtrů při inicializaci a aktualizaci widgetů. V tomto případě můžete použít volbu `filterCallback`: |
|||
|
|||
````js |
|||
var myWidgetManager = new abp.WidgetManager({ |
|||
wrapper: '#MyDashboardWidgetsArea', |
|||
filterCallback: function() { |
|||
return $('#MyDashboardFilterForm').serializeFormToObject(); |
|||
} |
|||
}); |
|||
```` |
|||
|
|||
Tento příklad ukazuje výchozí implementaci `filterCallback`. Pomocí polí můžete vrátit jakýkoli JavaScript objekt. Příklad: |
|||
|
|||
````js |
|||
filterCallback: function() { |
|||
return { |
|||
'startDate': $('#StartDateInput').val(), |
|||
'endDate': $('#EndDateInput').val() |
|||
}; |
|||
} |
|||
```` |
|||
|
|||
Vrácené filtry jsou předávány všem widgetům na `init` a` refresh`. |
|||
|
|||
### Widget JavaScript API |
|||
|
|||
Widget může definovat rozhraní API jazyka JavaScript, které je v případě potřeby vyvoláno přes `WidgetManager`. Ukázku kódu níže lze použít k definování API pro widget. |
|||
|
|||
````js |
|||
(function () { |
|||
abp.widgets.NewUserStatisticWidget = function ($wrapper) { |
|||
|
|||
var getFilters = function () { |
|||
return { |
|||
... |
|||
}; |
|||
} |
|||
|
|||
var refresh = function (filters) { |
|||
... |
|||
}; |
|||
|
|||
var init = function (filters) { |
|||
... |
|||
}; |
|||
|
|||
return { |
|||
getFilters: getFilters, |
|||
init: init, |
|||
refresh: refresh |
|||
}; |
|||
}; |
|||
})(); |
|||
```` |
|||
|
|||
`NewUserStatisticWidget` je tady název widgetu. Měl by odpovídat názvu widgetu definovanému na straně serveru. Všechny funkce jsou volitelné. |
|||
|
|||
#### getFilters |
|||
|
|||
Pokud má widget vlastní interní filtry, měla by tato funkce vrátit objekt filtru. Příklad: |
|||
|
|||
````js |
|||
var getFilters = function() { |
|||
return { |
|||
frequency: $wrapper.find('.frequency-filter option:selected').val() |
|||
}; |
|||
} |
|||
```` |
|||
|
|||
Tuto metodu používá `WidgetManager` při vytváření filtrů. |
|||
|
|||
#### init |
|||
|
|||
Slouží k inicializaci widgetu kdykoli je potřeba. Má argument filtru, který lze použít při získávání dat ze serveru. Metoda `init` je použita když je volána funkce `WidgetManager.init()`. Použita je i v případě že váš widget vyžaduje úplné obnovení při aktualizaci. Viz `RefreshUrl` v možnostech widgetu. |
|||
|
|||
#### refresh |
|||
|
|||
Slouží k aktualizaci widgetu kdykoli je potřeba. Má argument filtru, který lze použít při získávání dat ze serveru. Metoda `refresh` se používá kdykoliv je volána funkce `WidgetManager.refresh()`. |
|||
|
|||
## Autorizace |
|||
|
|||
Některé widgety budou pravděpodobně muset být dostupné pouze pro ověřené nebo autorizované uživatele. V tomto případě použijte následující vlastnosti atributu `Widget`: |
|||
|
|||
* `RequiresAuthentication` (`bool`): Nastavte na true, aby byl tento widget použitelný pouze pro ověřené uživatele (uživatel je přihlášen do aplikace). |
|||
* `RequiredPolicies` (`List<string>`): Seznam názvů zásad k autorizaci uživatele. Další informace o zásadách naleznete v [dokumentu autorizace](../Authorization.md). |
|||
|
|||
Příklad: |
|||
|
|||
````csharp |
|||
using Microsoft.AspNetCore.Mvc; |
|||
using Volo.Abp.AspNetCore.Mvc; |
|||
using Volo.Abp.AspNetCore.Mvc.UI.Widgets; |
|||
|
|||
namespace DashboardDemo.Web.Pages.Components.MySimpleWidget |
|||
{ |
|||
[Widget(RequiredPolicies = new[] { "MyPolicyName" })] |
|||
public class MySimpleWidgetViewComponent : AbpViewComponent |
|||
{ |
|||
public IViewComponentResult Invoke() |
|||
{ |
|||
return View(); |
|||
} |
|||
} |
|||
} |
|||
```` |
|||
|
|||
## WidgetOptions |
|||
|
|||
Jako alternativu k atributu `Widget` můžete ke konfiguraci widgetů použít `AbpWidgetOptions`: |
|||
|
|||
```csharp |
|||
Configure<AbpWidgetOptions>(options => |
|||
{ |
|||
options.Widgets.Add<MySimpleWidgetViewComponent>(); |
|||
}); |
|||
``` |
|||
|
|||
Toto vepište do metody `ConfigureServices` vašeho [modulu](../Module-Development-Basics.md). Veškerá konfigurace udělaná přes atribut `Widget` je dostupná i za pomoci `AbpWidgetOptions`. Příklad konfigurace, která přidává styl pro widget: |
|||
|
|||
````csharp |
|||
Configure<AbpWidgetOptions>(options => |
|||
{ |
|||
options.Widgets |
|||
.Add<MySimpleWidgetViewComponent>() |
|||
.WithStyles("/Pages/Components/MySimpleWidget/Default.css"); |
|||
}); |
|||
```` |
|||
|
|||
> Tip: `AbpWidgetOptions` lze také použít k získání existujícího widgetu a ke změně jeho konfigurace. To je obzvláště užitečné, pokud chcete změnit konfiguraci widgetu uvnitř modulu používaného vaší aplikací. Použíjte `options.Widgets.Find` k získání existujícího `WidgetDefinition`. |
|||
|
|||
## Podívejte se také na |
|||
|
|||
* [Příklad projektu (zdrojový kód)](https://github.com/abpframework/abp-samples/tree/master/DashboardDemo). |
|||
|
|||
@ -1,84 +0,0 @@ |
|||
# Autofac integrace |
|||
|
|||
Autofac je jedním z nejpoužívanějších frameworků pro .Net pro vkládání závislostí (DI). Poskytuje pokročilejší funkce v porovnáním se standardní .Net Core DI knihovnou, jako dynamickou proxy a injekci vlastností. |
|||
|
|||
## Instalace Autofac integrace |
|||
|
|||
> Všechny startovací šablony a vzorky jsou s Autofac již integrovány. Takže většinou nemusíte tento balíček instalovat ručně. |
|||
|
|||
Nainstalujte do vašeho projektu balíček [Volo.Abp.Autofac](https://www.nuget.org/packages/Volo.Abp.Autofac) (pro víceprojektovou aplikaci se doporučuje přidat do spustitelného/webového projektu.) |
|||
|
|||
```` |
|||
Install-Package Volo.Abp.Autofac |
|||
```` |
|||
|
|||
Poté přídejte k vašemu modulu závislost na `AbpAutofacModule`: |
|||
|
|||
```csharp |
|||
using Volo.Abp.Modularity; |
|||
using Volo.Abp.Autofac; |
|||
|
|||
namespace MyCompany.MyProject |
|||
{ |
|||
[DependsOn(typeof(AbpAutofacModule))] |
|||
public class MyModule : AbpModule |
|||
{ |
|||
//... |
|||
} |
|||
} |
|||
``` |
|||
|
|||
Nakonec nastavte `AbpApplicationCreationOptions` aby nahradil výchozí služby pro vkládání závislostí na Autofac. Záleží na typu aplikace. |
|||
|
|||
### ASP.NET Core aplikace |
|||
|
|||
Volejte `UseAutofac()` v souboru **Startup.cs** jako je ukázáno níže: |
|||
|
|||
````csharp |
|||
public class Startup |
|||
{ |
|||
public IServiceProvider ConfigureServices(IServiceCollection services) |
|||
{ |
|||
services.AddApplication<MyWebModule>(options => |
|||
{ |
|||
//Integrace Autofac! |
|||
options.UseAutofac(); |
|||
}); |
|||
|
|||
return services.BuildServiceProviderFromFactory(); |
|||
} |
|||
|
|||
public void Configure(IApplicationBuilder app) |
|||
{ |
|||
app.InitializeApplication(); |
|||
} |
|||
} |
|||
```` |
|||
|
|||
### Konzolová aplikace |
|||
|
|||
Volejte metodu `UseAutofac()` v možnostech `AbpApplicationFactory.Create` jako je ukázáno níže: |
|||
|
|||
````csharp |
|||
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 |
|||
})) |
|||
{ |
|||
//... |
|||
} |
|||
} |
|||
} |
|||
} |
|||
```` |
|||
|
|||
|
Before Width: | Height: | Size: 7.0 KiB |
|
Before Width: | Height: | Size: 4.6 KiB |
@ -1,167 +0,0 @@ |
|||
# ABP CLI |
|||
|
|||
ABP CLI (Command Line Interface) je nástroj v příkazovém řádku k provádění některých běžných úkonů v řešeních založených na ABP. |
|||
|
|||
## Instalace |
|||
|
|||
ABP CLI je [dotnet global tool](https://docs.microsoft.com/en-us/dotnet/core/tools/global-tools). Nainstalujete jej pomocí okna příkazového řádku: |
|||
|
|||
````bash |
|||
dotnet tool install -g Volo.Abp.Cli |
|||
```` |
|||
|
|||
Aktualizace stávající instalace: |
|||
|
|||
````bash |
|||
dotnet tool update -g Volo.Abp.Cli |
|||
```` |
|||
|
|||
## Příkazy |
|||
|
|||
### new |
|||
|
|||
Vygeneruje nové řešení založené na ABP [startovací šabloně](Startup-Templates/Index.md). |
|||
|
|||
Základní použití: |
|||
|
|||
````bash |
|||
abp new <název-řešení> [možnosti] |
|||
```` |
|||
|
|||
Příklad: |
|||
|
|||
````bash |
|||
abp new Acme.BookStore |
|||
```` |
|||
|
|||
* `Acme.BookStore` je tady název řešení. |
|||
* Běžná konvence je nazvat řešení stylem *VaseSpolecnost.VasProjekt*. Nicméně můžete použít i jiné pojmenování jako *VasProjekt* (jednostupňový jmenný prostor) nebo *VaseSpolecnost.VasProjekt.VasModul* (třístupňový jmenný prostor). |
|||
|
|||
#### Možnosti |
|||
|
|||
* `--template` nebo `-t`: Určuje název šablony. Výchozí šablona je `app`, která generuje webovou aplikaci. Dostupné šablony: |
|||
* `app` (výchozí): [Aplikační šablona](Startup-Templates/Application.md). Dodatečné možnosti: |
|||
* `--ui` nebo `-u`: Určuje UI framework. Výchozí framework je `mvc`. Dostupné frameworky: |
|||
* `mvc`: ASP.NET Core MVC. Pro tuto šablonu jsou dostupné dodatečné možnosti: |
|||
* `--tiered`: Vytvoří stupňovité řešení, kde jsou vrstvy Web a Http API fyzicky odděleny. Pokud není uvedeno, tak vytvoří vrstvené řešení, které je méně složité a vhodné pro většinu scénářů. |
|||
* `angular`: Angular. Pro tuto šablonu jsou dostupné dodatečné možnosti: |
|||
* `--separate-auth-server`: Oddělí Auth Server aplikaci od API host aplikace. Pokud není uvedeno, bude na straně serveru jediný koncový bod. |
|||
* `none`: Bez UI. Pro tuto šablonu jsou dostupné dodatečné možnosti: |
|||
* `--separate-auth-server`: Oddělí Auth Server aplikaci od API host aplikace. Pokud není uvedeno, bude na straně serveru jediný koncový bod. |
|||
* `--database-provider` nebo `-d`: Určuje poskytovatele databáze. Výchozí poskytovatel je `ef`. Dostupní poskytovatelé: |
|||
* `ef`: Entity Framework Core. |
|||
* `mongodb`: MongoDB. |
|||
* `module`: [Šablona modulu](Startup-Templates/Module.md). Dodatečné možnosti: |
|||
* `--no-ui`: Určuje nezahrnutí uživatelského rozhraní. Umožňuje vytvořit moduly pouze pro služby (a.k.a. mikroslužby - bez uživatelského rozhraní). |
|||
* `--output-folder` nebo `-o`: Určuje výstupní složku. Výchozí hodnota je aktuální adresář. |
|||
* `--version` nebo `-v`: Určuje verzi ABP & šablony. Může to být [štítek vydání](https://github.com/abpframework/abp/releases) nebo [název větve](https://github.com/abpframework/abp/branches). Pokud není uvedeno, používá nejnovější vydání. Většinou budete chtít použít nejnovější verzi. |
|||
|
|||
|
|||
### add-package |
|||
|
|||
Přidá ABP balíček do projektu, |
|||
|
|||
* Přidáním souvisejícícho nuget balíčku jako závislost do projektu. |
|||
* Přidáním `[DependsOn(...)]` atributu k modulové tříde v projektu (podívejte se na [dokument vývoje modulu](Module-Development-Basics.md)). |
|||
|
|||
> Všimněte si, že přidaný modul může vyžadovat další konfiguraci, která je obecně uvedena v dokumentaci příslušného balíčku. |
|||
|
|||
Základní použití: |
|||
|
|||
````bash |
|||
abp add-package <název-balíčku> [možnosti] |
|||
```` |
|||
|
|||
Příklad: |
|||
|
|||
```` |
|||
abp add-package Volo.Abp.MongoDB |
|||
```` |
|||
|
|||
* Tento příklad přidá do projektu balíček Volo.Abp.MongoDB. |
|||
|
|||
#### Možnosti |
|||
|
|||
* `--project` nebo `-p`: Určuje cestu k projektu (.csproj). Pokud není zadáno, CLI se pokusí najít soubor .csproj v aktuálním adresáři. |
|||
|
|||
### add-module |
|||
|
|||
Přidá [více-balíčkový aplikační modul](Modules/Index) k řešení tím, že najde všechny balíčky modulu, vyhledá související projekty v řešení a přidá každý balíček do odpovídajícího projektu v řešení. |
|||
|
|||
> Modul se obecně skládá z několika balíčků (z důvodu vrstvení, různých možností poskytovatele databáze nebo jiných důvodů). Použití příkazu `add-module` dramaticky zjednodušuje přidání modulu do řešení. Každý modul však může vyžadovat další konfiguraci, která je obecně uvedena v dokumentaci příslušného modulu. |
|||
|
|||
Základní použití: |
|||
|
|||
````bash |
|||
abp add-module <název-modulu> [možnosti] |
|||
```` |
|||
|
|||
Příklad: |
|||
|
|||
```bash |
|||
abp add-module Volo.Blogging |
|||
``` |
|||
|
|||
* Tento příklad přidá do projektu modul Volo.Blogging. |
|||
|
|||
#### Možnosti |
|||
|
|||
* `--solution` nebo `-s`: Určuje cestu k řešení (.sln). Pokud není zadáno, CLI se pokusí najít soubor .sln v aktuálním adresáři. |
|||
* `--skip-db-migrations`: Pro poskytovatele databáze EF Core automaticky přidá nový kód první migrace (`Add-Migration`) a v případě potřeby aktualizuje databázi (`Update-Database`). Tuto možnost určete k vynechání této operace. |
|||
* `-sp` nebo `--startup-project`: Relativní cesta ke složce spouštěcího projektu. Výchozí hodnota je aktuální adresář. |
|||
* `--with-source-code`: Místo balíčků NuGet/NPM přidejte zdrojový kód modulu. |
|||
|
|||
### update |
|||
|
|||
Aktualizace všech balíčků souvisejících s ABP může být únavná, protože existuje mnoho balíčků frameworku a modulů. Tento příkaz automaticky aktualizuje na poslední verze všechny související ABP NuGet a NPM balíčky v řešení nebo projektu. |
|||
|
|||
Použití: |
|||
|
|||
````bash |
|||
abp update [možnosti] |
|||
```` |
|||
|
|||
* Pokud spouštíte v adresáři se souborem .sln, aktualizuje všechny balíčky všech projektů v řešení souvisejících s ABP na nejnovější verze. |
|||
* Pokud spouštíte v adresáři se souborem .csproj, aktualizuje všechny balíčky v projektu na nejnovější verze. |
|||
|
|||
#### Možnosti |
|||
|
|||
* `--include-previews` nebo `-p`: Zahrne náhledové, beta a rc balíčky při kontrole nových verzí. |
|||
* `--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. |
|||
|
|||
Použítí: |
|||
|
|||
````bash |
|||
abp help [název-příkazu] |
|||
```` |
|||
|
|||
Příklady: |
|||
|
|||
````bash |
|||
abp help # Zobrazí obecnou nápovědu. |
|||
abp help new # Zobrazí nápovědu k příkazu "new". |
|||
```` |
|||
|
|||
@ -1,64 +0,0 @@ |
|||
## Průvodce pro přispěvatele |
|||
|
|||
ABP je [open source](https://github.com/abpframework) a komunitně řízený projekt. Tento průvodce má za cíl pomoci každému kdo chce do projektu nějak přispět. |
|||
|
|||
### Příspěvek kódu |
|||
|
|||
Vždy můžete zaslat pull request do Github repositáře. |
|||
|
|||
- Naklonujte [ABP repozitář](https://github.com/abpframework/abp/) z Githubu. |
|||
- Učiňte potřebné změny. |
|||
- Zašlete pull request. |
|||
|
|||
Než budete dělat nějaké změny, diskutujte o nich prosím na [Github problémy](https://github.com/abpframework/abp/issues). Díky tomu nebude žádný jiný vývojář pracovat na stejném problému a Váš PR má lepší šanci na to být přijat. |
|||
|
|||
#### Opravy chyb a vylepšení |
|||
|
|||
Pokud chcete opravit známou chybu nebo pracovat na plánovaném vylepšení podívejte se na [seznam problémů](https://github.com/abpframework/abp/issues) na Githubu. |
|||
|
|||
#### Požadavky na funkce |
|||
|
|||
Pokud máte nápad na funkci pro framework nebo modul [vytvořte problém](https://github.com/abpframework/abp/issues/new) na Githubu nebo se připojte ke stávající diskuzi. V případě přijetí komunitou ho pak můžete implementovat. |
|||
|
|||
### Překlad dokumentů |
|||
|
|||
Pokud chcete přeložit celou [dokumentaci](https://abp.io/documents/) (včetně této stránky) do Vašeho rodného jazyka, následujte tyto kroky: |
|||
|
|||
* Naklonujte [ABP repozitář](https://github.com/abpframework/abp/) z Githubu. |
|||
* K přidání nového jazyka vytvořte novou složku v [docs](https://github.com/abpframework/abp/tree/master/docs). Název složky musí být "en", "es", "fr", "tr" atd. v závislosti na jazyku (navštivte [všechny jazykové kódy](https://msdn.microsoft.com/en-us/library/hh441729.aspx)). |
|||
* 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 jsou 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. |
|||
|
|||
K tomu mají framework a vestavěné moduly již lokalizované texty. Například [lokalizační texty pro Volo.Abp.UI balík](https://github.com/abpframework/abp/blob/master/framework/src/Volo.Abp.UI/Localization/Resources/AbpUi/en.json). |
|||
|
|||
Můžete vytvořit nový soubor ve [stejné složce](https://github.com/abpframework/abp/tree/master/framework/src/Volo.Abp.UI/Localization/Resources/AbpUi) k přidání překladu. |
|||
|
|||
* Naklonujte [ABP repozitář](https://github.com/abpframework/abp/) z Githubu. |
|||
* Vytvořte nový soubor pro cílový jazyk pro lokalizační text v (json) souboru (u souboru en.json). |
|||
* Zkopírujte veškerý text ze souboru en.json. |
|||
* Přeložte texty. |
|||
* Zašlete pull request na Githubu. |
|||
|
|||
K překladu lokalizovaných textů můžete také použít příkaz `abp translate` of [ABP CLI](CLI.md). |
|||
|
|||
ABP je modulářní framework, proto je zde mnoho zdrojů lokalizačních textů, jeden pro každý modul. K najití všech .json souborů, vyhledejte po naklonování repozitáře soubory "en.json". Můžete se taky podívat na [tento seznam](Localization-Text-Files.md) souborů lokalizačních textů. |
|||
|
|||
### Příspevky do blogu a návody |
|||
|
|||
Pokud se rozhodnete pro ABP vytvořit nějaké návody nebo příspěvky do blogu, dejte nám vědět (prostřednictvím [Github problémy](https://github.com/abpframework/abp/issues)), ať můžeme přidat odkaz na Váš návod/příspěvek v oficiální dokumentaci a oznámit na našem [Twitter účtu](https://twitter.com/abpframework). |
|||
|
|||
### Zpráva o chybě |
|||
|
|||
Pokud najdete chybu, [vytvořte prosím problém v Github repozitáři](https://github.com/abpframework/abp/issues/new). |
|||
@ -1,61 +0,0 @@ |
|||
# Dapper integrace |
|||
|
|||
Jelikož myšlenka Dapper je taková, že sql příkaz má přednost, tak hlavně poskytuje metody rozšíření pro `IDbConnection` rozhraní. |
|||
|
|||
Abp nezapouzdřuje přílíš mnoho funkcí pro Dapper. Abp Dapper poskytuje základní třídu `DapperRepository<TDbContext>` založenou na Abp EntityFrameworkCore, který poskytuje vlastnosti `IDbConnection` a `IDbTransaction` vyžadované v Dapper. |
|||
|
|||
Tyto dvě vlastnosti fungují dobře s [jednotkou práce](Unit-Of-Work.md). |
|||
|
|||
## Instalace |
|||
|
|||
Nainstalujte a nakonfigurujte EF Core podle [EF Core integrační dokumentace](Entity-Framework-Core.md). |
|||
|
|||
`Volo.Abp.Dapper` je hlavní NuGet balík pro Dapper integraci. Nainstalujte jej proto do vašeho projektu (pro strukturovanou aplikaci do datové/infrastrukturní vrstvy): |
|||
|
|||
```shell |
|||
Install-Package Volo.Abp.Dapper |
|||
``` |
|||
|
|||
Poté přidejte závislost na `AbpDapperModule` modulu (atribut `DependsOn`) do Vašeho [modulu](Module-Development-Basics.md): |
|||
|
|||
````C# |
|||
using Volo.Abp.Dapper; |
|||
using Volo.Abp.Modularity; |
|||
|
|||
namespace MyCompany.MyProject |
|||
{ |
|||
[DependsOn(typeof(AbpDapperModule))] |
|||
public class MyModule : AbpModule |
|||
{ |
|||
//... |
|||
} |
|||
} |
|||
```` |
|||
|
|||
## Implementace Dapper repozitáře |
|||
|
|||
Následující kód implementuje repozitář `Person`, který vyžaduje `DbContext` z EF Core (MyAppDbContext). Můžete vložit `PersonDapperRepository` k volání jeho metod. |
|||
|
|||
`DbConnection` a `DbTransaction` jsou ze základní třídy `DapperRepository`. |
|||
|
|||
```C# |
|||
public class PersonDapperRepository : DapperRepository<MyAppDbContext>, ITransientDependency |
|||
{ |
|||
public PersonDapperRepository(IDbContextProvider<MyAppDbContext> dbContextProvider) |
|||
: base(dbContextProvider) |
|||
{ |
|||
} |
|||
|
|||
public virtual async Task<List<string>> GetAllPersonNames() |
|||
{ |
|||
return (await DbConnection.QueryAsync<string>("select Name from People", transaction: DbTransaction)) |
|||
.ToList(); |
|||
} |
|||
|
|||
public virtual async Task<int> UpdatePersonNames(string name) |
|||
{ |
|||
return await DbConnection.ExecuteAsync("update People set Name = @NewName", new { NewName = name }, |
|||
DbTransaction); |
|||
} |
|||
} |
|||
``` |
|||
@ -1,33 +0,0 @@ |
|||
# Domain Driven Design |
|||
|
|||
## Co je DDD? |
|||
|
|||
ABP framework poskytuje **infrastrukturu**, která zjednodušuje implementaci vývoje založeného na **DDD**. DDD je [definován ve Wikipedii](https://en.wikipedia.org/wiki/Domain-driven_design) takto: |
|||
|
|||
> **Domain-driven design** (**DDD**) je přístup k vývoji softwaru pro komplexní potřeby propojením implementace s vyvíjejícím se modelem. Předpoklad DDD je následující: |
|||
> |
|||
> - Primární zaměření projektu je na jádře domény a doménové logice; |
|||
> - Zakládání komplexních návrhů na modelu domény; |
|||
> - Iniciování tvůrčí spolupráce mezi technickými a doménovými odborníky s cílem iterativně zdokonalit koncepční model, který řeší konkrétní problémy v doméně. |
|||
|
|||
### Vrstvy |
|||
|
|||
ABP dodržuje principy a vzorce DDD pro dosažení vrstveného aplikačního modelu, který se skládá ze čtyř základních vrstev: |
|||
|
|||
- **Prezentační vrstva**: Poskytuje uživateli rozhraní. Používá *Aplikační vrstvu* k dosažení uživatelských interakcí. |
|||
- **Aplikační vrstva**: Prostředník mezi prezentační a doménovou vrstvou. Instrumentuje business objekty k provádění specifických úloh aplikace. Implementuje případy použití jako logiku aplikace. |
|||
- **Doménová vrstva**: Zahrnuje business objekty a jejich business pravidla. Je jádrem aplikace. |
|||
- **Vrstva infrastruktury**: Poskytuje obecné technické možnosti, které podporují vyšší vrstvy většinou pomocí knihoven třetích stran. |
|||
|
|||
## Obsah |
|||
|
|||
* **Doménová vrstva** |
|||
* [Entity & agregované kořeny](Entities.md) |
|||
* Hodnotové objekty |
|||
* [Repozitáře](Repositories.md) |
|||
* Doménové služby |
|||
* Specifikace |
|||
* **Aplikační vrstva** |
|||
* [Aplikační služby](Application-Services.md) |
|||
* [Objekty přenosu dat (DTOs)](Data-Transfer-Objects.md) |
|||
* Jednotka práce |
|||
@ -1,39 +0,0 @@ |
|||
# Přepnutí na EF Core PostgreSQL providera |
|||
|
|||
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. |
|||
|
|||
## Výměna balíku Volo.Abp.EntityFrameworkCore.SqlServer |
|||
|
|||
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). |
|||
|
|||
## 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;`). |
|||
|
|||
## UseNpgsql() |
|||
|
|||
Najděte volání `UseSqlServer()` v *YourProjectName*EntityFrameworkCoreModule.cs uvnitř projektu `.EntityFrameworkCore` a nahraďte za `UseNpgsql()`. |
|||
|
|||
Najděte volání `UseSqlServer()` v *YourProjectName*MigrationsDbContextFactory.cs uvnitř projektu `.EntityFrameworkCore.DbMigrations` a nahraďte za `UseNpgsql()`. |
|||
|
|||
> V závislosti na struktuře řešení můžete najít více volání `UseSqlServer()`, které je třeba změnit. |
|||
|
|||
## Změna connection stringů |
|||
|
|||
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ů. |
|||
|
|||
Typicky je potřeba změnit `appsettings.json` v projektech `.DbMigrator` a `.Web` projects, ale to záleží na vaší struktuře řešení. |
|||
|
|||
## Regenerace migrací |
|||
|
|||
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). |
|||
|
|||
Tímto vytvoříte migraci databáze se všemi nakonfigurovanými databázovými objekty (tabulkami). |
|||
|
|||
Spusťte projekt `.DbMigrator` k vytvoření databáze a vložení počátečních dat. |
|||
|
|||
## Spuštění aplikace |
|||
|
|||
Vše je připraveno. Stačí už jen spustit aplikaci a užívat si kódování. |
|||
@ -1,126 +0,0 @@ |
|||
## Začínáme s Angular aplikační šablonou |
|||
|
|||
Tento tutoriál vysvětluje, jak vytvořit novou Angular aplikaci pomocí spouštěcí šablony, jak ji nakonfigurovat a spustit. |
|||
|
|||
### Tvorba nového projektu |
|||
|
|||
Tento tutorial používá k vytvoření 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 jste tak dosud neučinili, nainstalujte ABP CLI pomocí okna příkazového řádku: |
|||
|
|||
````bash |
|||
dotnet tool install -g Volo.Abp.Cli |
|||
```` |
|||
|
|||
Použíjte příkaz `abp new` v prázdné složce k vytvoření Vašeho projektu: |
|||
|
|||
````bash |
|||
abp new Acme.BookStore -u angular |
|||
```` |
|||
|
|||
> Můžete použít různé úrovně jmenných prostorů; např. BookStore, Acme.BookStore nebo Acme.Retail.BookStore. |
|||
|
|||
`-u angular` volba specifikuje Angular jako UI framework. Výchozí poskytovatel databáze je EF Core. Podívejte se na [CLI dokumentaci](CLI.md) pro všechny dostupné možnosti. |
|||
|
|||
#### Předběžné požadavky |
|||
|
|||
Vytvořené řešení vyžaduje; |
|||
|
|||
* [Visual Studio 2019 (v16.4.0+)](https://visualstudio.microsoft.com/vs/) |
|||
* [.NET Core 3.0+](https://www.microsoft.com/net/download/dotnet-core/) |
|||
* [Node v12+](https://nodejs.org) |
|||
* [Yarn v1.19+](https://classic.yarnpkg.com/) |
|||
|
|||
### Struktura řešení |
|||
|
|||
Otevřete řešení ve **Visual Studio**: |
|||
|
|||
 |
|||
|
|||
Řešení má vrstvenou strukturu (založenou na [domain driven designu](Domain-Driven-Design.md)) a obsahuje projekty testů jednotek a integrace správně nakonfigurované pro práci s **EF Core** & **SQLite in-memory** databází. |
|||
|
|||
> Podívejte se na [dokument šablony aplikace](Startup-Templates/Application.md) k detailnímu pochopení struktury řešení. |
|||
|
|||
### Databázový connection string |
|||
|
|||
Zkontrolujte **connection string** v souboru `appsettings.json` u projektu `.HttpApi.Host`: |
|||
|
|||
````json |
|||
{ |
|||
"ConnectionStrings": { |
|||
"Default": "Server=localhost;Database=BookStore;Trusted_Connection=True" |
|||
} |
|||
} |
|||
```` |
|||
|
|||
Řešení je nakonfigurováno pro použití **Entity Framework Core** s **MS SQL Server**. EF Core podporuje [různé](https://docs.microsoft.com/en-us/ef/core/providers/) poskytovatele databáze, takže pokud chcete můžete použít jiný DBMS. V případě potřeby změňte connection string. |
|||
|
|||
### Tvorba databáze & aplikace migrací databáze |
|||
|
|||
K vytvoření databáze máte dvě možnosti. |
|||
|
|||
#### Použití aplikace DbMigrator |
|||
|
|||
Řešení obsahuje konzolovou aplikaci (v tomto příkladu nazvanou `Acme.BookStore.DbMigrator`), která dokáže vytvořit databázi, aplikovat migrace a vložit počáteční data. Ta je užitečná jak pro vývojové tak pro produkční prostředí. |
|||
|
|||
> `.DbMigrator` má vlastní `appsettings.json`. Pokud jste změnili connection string výše, měli byste změnit i tento. |
|||
|
|||
Klikněte pravým na projekt `.DbMigrator` zvolte **Set as StartUp Project**: |
|||
|
|||
 |
|||
|
|||
Zmáčkněte F5 (nebo Ctrl+F5) ke spuštění aplikace. Výstup by měl být podobný vyobrazení níže: |
|||
|
|||
 |
|||
|
|||
#### Použití příkazu EF Core Update-Database |
|||
|
|||
Ef Core máš příkaz `Update-Database`, který v případě potřeby vytvoří databázi a aplikuje čekající migrace. Klikněte pravým na projekt `.HttpApi.Host` a zvolte **Set as StartUp Project**: |
|||
|
|||
 |
|||
|
|||
Otevřete **Package Manager Console**, zvolte `.EntityFrameworkCore.DbMigrations` jako **Default Project** a proveďte příkaz `Update-Database`: |
|||
|
|||
 |
|||
|
|||
Tímto vytvoříte novou databáze podle nakonfigurovaného connection string. |
|||
|
|||
> Je doporučeno užití nástroje `.DbMigrator`, protože zároveň vloží i počáteční data ke správnému běhu webové aplikace. |
|||
|
|||
### Spuštění aplikace |
|||
|
|||
#### Spuštění API Host (na straně serveru) |
|||
|
|||
Ujistěte se že je projekt `.HttpApi.Host` nastaven jako startovací a spusťte aplikaci což otevře Swagger UI: |
|||
|
|||
 |
|||
|
|||
Tady můžete vidět API aplikace a zároveň je i otestovat. Získejte [více informací](https://swagger.io/tools/swagger-ui/) o Swagger UI. |
|||
|
|||
##### Autorizace pro Swagger UI |
|||
|
|||
Vetšina API aplikace vyžaduje autentizaci & autorizaci. Pokud chcete otestovat autorizované API, manuálně přejděte na stránku `/Account/Login`, vložte `admin` jako uživatelské jméno a `1q2w3E*` jako heslo k příhlášení do aplikace. Poté budete moci provádět autorizované požadavky API. |
|||
|
|||
#### Spuštění Angular aplikace (na straně klienta) |
|||
|
|||
Přejděte do složky `angular`, otevřete terminál příkazového řádku, proveďte příkaz `yarn` (doporučujeme používat správce balíků [yarn](https://yarnpkg.com), npm install bude v mnoha případech také fungovat): |
|||
|
|||
````bash |
|||
yarn |
|||
```` |
|||
|
|||
Jakmile jsou načteny všechny node moduly, proveďte příkaz `yarn start` nebo `npm start`: |
|||
|
|||
````bash |
|||
yarn start |
|||
```` |
|||
|
|||
Otevřete Váš oblíbený prohlížeč a přejděte na adresu `localhost:4200`. Počáteční uživatelské jméno je `admin` a heslo `1q2w3E*`. |
|||
|
|||
Startovací šablona obsahuje moduly **správa identit** a **správa tenantů**. Jakmile se přihlásíte, zprístupní se administrační menu kde můžete spravovat **tenanty**, **role**, **uživatele** a jejich **oprávnění**. |
|||
|
|||
> Doporučujeme [Visual Studio Code](https://code.visualstudio.com/) jako editor pro Angular projekt, ale klidně použijte Váš oblíbený editor. |
|||
|
|||
### Co dále? |
|||
|
|||
* [Tutoriál vývoje aplikace](Tutorials/Angular/Part-I.md) |
|||
@ -1,157 +0,0 @@ |
|||
# 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 AspNet Core Web aplikaci ve Visual Studio 2019 (16.4.0+): |
|||
|
|||
 |
|||
|
|||
2. Nakonfigurujte váš nový projekt: |
|||
|
|||
 |
|||
|
|||
3. Potvrďte kliknutím na tlačítko vytvořit |
|||
|
|||
 |
|||
|
|||
## 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.Extensions.Hosting; |
|||
using Volo.Abp; |
|||
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(); |
|||
} |
|||
else |
|||
{ |
|||
app.UseExceptionHandler("/Error"); |
|||
} |
|||
|
|||
app.UseStaticFiles(); |
|||
app.UseRouting(); |
|||
app.UseConfiguredEndpoints(); |
|||
} |
|||
} |
|||
} |
|||
```` |
|||
|
|||
``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ém. V kódu výše, ``AppModule`` má závislost na ``AbpAspNetCoreMvcModule`` (definován v balíku [Volo.Abp.AspNetCore.Mvc](https://www.nuget.org/packages/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 Microsoft.AspNetCore.Builder; |
|||
using Microsoft.Extensions.DependencyInjection; |
|||
|
|||
namespace BasicAspNetCoreApplication |
|||
{ |
|||
public class Startup |
|||
{ |
|||
public void ConfigureServices(IServiceCollection services) |
|||
{ |
|||
services.AddApplication<AppModule>(); |
|||
} |
|||
|
|||
public void Configure(IApplicationBuilder app) |
|||
{ |
|||
app.InitializeApplication(); |
|||
} |
|||
} |
|||
} |
|||
```` |
|||
|
|||
``services.AddApplication<AppModule>()`` přidává všechny služby definované ve všech modulech počínaje od ``AppModule``. |
|||
|
|||
``app.InitializeApplication()`` v metodě ``Configure`` inicializuje a spustí aplikaci. |
|||
|
|||
## Spusťte aplikaci! |
|||
|
|||
To je vše! Spusťte aplikaci, bude fungovat podle očekávání. |
|||
|
|||
## 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) dostatečný pro základní požadavky, [Autofac](https://autofac.org/) 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. Upravíme `Program.cs` aby používal Autofac: |
|||
|
|||
````csharp |
|||
using Microsoft.AspNetCore.Hosting; |
|||
using Microsoft.Extensions.Hosting; |
|||
|
|||
namespace BasicAspNetCoreApplication |
|||
{ |
|||
public class Program |
|||
{ |
|||
public static void Main(string[] args) |
|||
{ |
|||
CreateHostBuilder(args).Build().Run(); |
|||
} |
|||
|
|||
public static IHostBuilder CreateHostBuilder(string[] args) => |
|||
Host.CreateDefaultBuilder(args) |
|||
.ConfigureWebHostDefaults(webBuilder => |
|||
{ |
|||
webBuilder.UseStartup<Startup>(); |
|||
}) |
|||
.UseAutofac(); // Přidejte tento řádek |
|||
} |
|||
} |
|||
```` |
|||
|
|||
## 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-samples/tree/master/BasicAspNetCoreApplication). |
|||
|
|||
@ -1,104 +0,0 @@ |
|||
## 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 2019 (v16.4.0+)](https://visualstudio.microsoft.com/vs/) |
|||
* [.NET Core 3.0+](https://www.microsoft.com/net/download/dotnet-core/) |
|||
* [Node v12+](https://nodejs.org) |
|||
* [Yarn v1.19+](https://classic.yarnpkg.com/) |
|||
|
|||
### Struktura řešení |
|||
|
|||
Otevřete řešení ve **Visual Studio**: |
|||
|
|||
 |
|||
|
|||
Ř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 aplikace](Startup-Templates/Application.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**: |
|||
|
|||
 |
|||
|
|||
Zmáčkněte F5 (nebo Ctrl+F5) ke spuštění aplikace. Výstup bude vypadat následovně: |
|||
|
|||
 |
|||
|
|||
#### 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**: |
|||
|
|||
 |
|||
|
|||
Otevřete **Package Manager Console**, vyberte projekt `.EntityFrameworkCore.DbMigrations` jako **Default Project** and spusťte příkaz `Update-Database`: |
|||
|
|||
 |
|||
|
|||
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: |
|||
|
|||
 |
|||
|
|||
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: |
|||
|
|||
 |
|||
|
|||
### Co dále? |
|||
|
|||
* [Tutoriál vývoje aplikace](Tutorials/AspNetCore-Mvc/Part-I.md) |
|||
@ -1,181 +0,0 @@ |
|||
# 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: |
|||
|
|||
 |
|||
|
|||
## 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-samples/tree/master/BasicConsoleApplication). |
|||
@ -1,25 +0,0 @@ |
|||
# ABP dokumentace |
|||
|
|||
ABP je **open source aplikační framework** se zaměřením na vývoj webových aplikací založených na ASP.NET Core, zároveň ho však lze využít i k vývoji jiných typů aplikací. |
|||
|
|||
K procházení dokumentace využijte navigační nabídky vlevo. |
|||
|
|||
## Začínáme |
|||
|
|||
Nejsnazší cestou jak začít nový projekt s ABP je užití startovací šablony: |
|||
|
|||
* [ASP.NET Core MVC (Razor Pages) UI Počáteční Šablona](Getting-Started-AspNetCore-MVC-Template.md) |
|||
* [Angular UI Počáteční Šablona](Getting-Started-Angular-Template.md) |
|||
|
|||
Pokud chcete začít od nuly (s prázdným projektem) tak manuálně nainstalujte ABP Framework s pomocí následujících tutoriálů: |
|||
|
|||
* [Konzolová Aplikace](Getting-Started-Console-Application.md) |
|||
* [ASP.NET Core Web Aplikace](Getting-Started-AspNetCore-Application.md) |
|||
|
|||
## Zdrojový kód |
|||
|
|||
ABP je hostovaný na GitHub. Zobrazit [zdrojový kód](https://github.com/abpframework/abp). |
|||
|
|||
## Chcete přispět? |
|||
|
|||
ABP je komunitně řízený open source projekt. Podívejte se na [průvodce pro přispěvatele](Contribution/Index.md) pokud chcete být součástí tohoto projektu. |
|||
@ -1,26 +0,0 @@ |
|||
# Noční sestavení |
|||
|
|||
Všechny balíky frameworku a modulů jsou každý večer nasazeny na MyGet. Takže můžete používat nebo testovat nejnovější kód bez čekání na další vydání. |
|||
|
|||
## Konfigurace Visual Studia |
|||
|
|||
> Vyžaduje Visual Studio 2017+ |
|||
|
|||
1. Přejděte do `Tools > Options > NuGet Package Manager > Package Source`. |
|||
2. Klikněte na zelenou ikonku `+`. |
|||
3. Nastavte `ABP Nightly` jako *Name* a `https://www.myget.org/F/abp-nightly/api/v3/index.json` jako *Source* podle vyobrazení níže: |
|||
 |
|||
4. Klikněte na `Update`. |
|||
5. Klikněte na `OK` k uložení změn. |
|||
|
|||
## Instalace balíku |
|||
|
|||
Nyní můžete instalovat náhledové / noční balíky do Vašeho projektu z NuGet prohlížeče nebo Package Manager Console. |
|||
|
|||
 |
|||
|
|||
1. V nuget prohlížeči, vyberte "Include prereleases". |
|||
2. Změňte zdroj balíků na "All". |
|||
3. Vyhledejte balík. Uvidíte prerelease balík formátovaný jako `(VERZE)-preview(DATUM)` (např *v0.16.0-preview20190401* jako v tomto vzorku). |
|||
4. Můžete kliknout na `Install` k přídání balíku do projektu. |
|||
|
|||
@ -1,376 +0,0 @@ |
|||
{ |
|||
"items": [ |
|||
{ |
|||
"text": "Začínáme", |
|||
"items": [ |
|||
{ |
|||
"text": "Ze startovacích šablon", |
|||
"items": [ |
|||
{ |
|||
"text": "Aplikace s MVC (Razor Pages) UI", |
|||
"path": "Getting-Started-AspNetCore-MVC-Template.md" |
|||
}, |
|||
{ |
|||
"text": "Aplikace s Angular UI", |
|||
"path": "Getting-Started-Angular-Template.md" |
|||
} |
|||
] |
|||
}, |
|||
{ |
|||
"text": "Z prázdných projektů", |
|||
"items": [ |
|||
{ |
|||
"text": "S ASP.NET Core Web aplikací", |
|||
"path": "Getting-Started-AspNetCore-Application.md" |
|||
}, |
|||
{ |
|||
"text": "S konzolovou aplikací", |
|||
"path": "Getting-Started-Console-Application.md" |
|||
} |
|||
] |
|||
} |
|||
] |
|||
}, |
|||
{ |
|||
"text": "Tutoriály", |
|||
"items": [ |
|||
{ |
|||
"text": "Vývoj aplikace", |
|||
"items": [ |
|||
{ |
|||
"text": "S ASP.NET Core MVC UI", |
|||
"path": "Tutorials/AspNetCore-Mvc/Part-I.md" |
|||
}, |
|||
{ |
|||
"text": "S Angular UI", |
|||
"path": "Tutorials/Angular/Part-I.md" |
|||
} |
|||
] |
|||
} |
|||
] |
|||
}, |
|||
{ |
|||
"text": "CLI", |
|||
"path": "CLI.md" |
|||
}, |
|||
{ |
|||
"text": "Základy", |
|||
"items": [ |
|||
{ |
|||
"text": "Konfigurace", |
|||
"path": "Configuration.md" |
|||
}, |
|||
{ |
|||
"text": "Možnosti", |
|||
"path": "Options.md" |
|||
}, |
|||
{ |
|||
"text": "Vkládání závislostí", |
|||
"path": "Dependency-Injection.md", |
|||
"items": [ |
|||
{ |
|||
"text": "AutoFac integrace", |
|||
"path": "Autofac-Integration.md" |
|||
} |
|||
] |
|||
}, |
|||
{ |
|||
"text": "Virtuální systém souborů", |
|||
"path": "Virtual-File-System.md" |
|||
}, |
|||
{ |
|||
"text": "Lokalizace", |
|||
"path": "Localization.md" |
|||
}, |
|||
{ |
|||
"text": "Zpracování výjimek", |
|||
"path": "Exception-Handling.md" |
|||
}, |
|||
{ |
|||
"text": "Validace", |
|||
"path": "Validation.md", |
|||
"items": [ |
|||
{ |
|||
"text": "FluentValidation integrace", |
|||
"path": "FluentValidation.md" |
|||
} |
|||
] |
|||
}, |
|||
{ |
|||
"text": "Autorizace", |
|||
"path": "Authorization.md" |
|||
}, |
|||
{ |
|||
"text": "Ukládání do mezipaměti", |
|||
"path": "Caching.md" |
|||
}, |
|||
{ |
|||
"text": "Audit" |
|||
}, |
|||
{ |
|||
"text": "Nastavení", |
|||
"path": "Settings.md" |
|||
} |
|||
] |
|||
}, |
|||
{ |
|||
"text": "Události", |
|||
"items": [ |
|||
{ |
|||
"text": "Event bus (místní)" |
|||
}, |
|||
{ |
|||
"text": "Distribuovaný event bus", |
|||
"items": [ |
|||
{ |
|||
"text": "RabbitMQ integrace" |
|||
} |
|||
] |
|||
} |
|||
] |
|||
}, |
|||
{ |
|||
"text": "Služby", |
|||
"items": [ |
|||
{ |
|||
"text": "Současný uživatel", |
|||
"path": "CurrentUser.md" |
|||
}, |
|||
{ |
|||
"text": "Mapování objekt na objekt", |
|||
"path": "Object-To-Object-Mapping.md" |
|||
}, |
|||
{ |
|||
"text": "Serializace objektu" |
|||
}, |
|||
{ |
|||
"text": "Serializace JSON" |
|||
}, |
|||
{ |
|||
"text": "Emailování" |
|||
}, |
|||
{ |
|||
"text": "GUIDy" |
|||
}, |
|||
{ |
|||
"text": "Vláknování" |
|||
}, |
|||
{ |
|||
"text": "Časování" |
|||
} |
|||
] |
|||
}, |
|||
{ |
|||
"text": "Multitenance", |
|||
"path": "Multi-Tenancy.md" |
|||
}, |
|||
{ |
|||
"text": "Vývoj modulů", |
|||
"items": [ |
|||
{ |
|||
"text": "Základy", |
|||
"path": "Module-Development-Basics.md" |
|||
}, |
|||
{ |
|||
"text": "Zásuvné moduly" |
|||
}, |
|||
{ |
|||
"text": "Nejlepší praktiky", |
|||
"path": "Best-Practices/Index.md" |
|||
} |
|||
] |
|||
}, |
|||
{ |
|||
"text": "Domain driven design", |
|||
"path": "Domain-Driven-Design.md", |
|||
"items": [ |
|||
{ |
|||
"text": "Doménová vrstva", |
|||
"items": [ |
|||
{ |
|||
"text": "Entity & agregované kořeny", |
|||
"path": "Entities.md" |
|||
}, |
|||
{ |
|||
"text": "Hodnotové objekty" |
|||
}, |
|||
{ |
|||
"text": "Repozitáře", |
|||
"path": "Repositories.md" |
|||
}, |
|||
{ |
|||
"text": "Doménové služby" |
|||
}, |
|||
{ |
|||
"text": "Specifikace" |
|||
} |
|||
] |
|||
}, |
|||
{ |
|||
"text": "Aplikační vrstva", |
|||
"items": [ |
|||
{ |
|||
"text": "Aplikační služby", |
|||
"path": "Application-Services.md" |
|||
}, |
|||
{ |
|||
"text": "Objekty přenosu dat" |
|||
}, |
|||
{ |
|||
"text": "Jednotka práce" |
|||
} |
|||
] |
|||
} |
|||
] |
|||
}, |
|||
{ |
|||
"text": "ASP.NET Core", |
|||
"items": [ |
|||
{ |
|||
"text": "API", |
|||
"items": [ |
|||
{ |
|||
"text": "Automatické API řadiče", |
|||
"path": "AspNetCore/Auto-API-Controllers.md" |
|||
}, |
|||
{ |
|||
"text": "Dynamičtí C# API klienti", |
|||
"path": "AspNetCore/Dynamic-CSharp-API-Clients.md" |
|||
} |
|||
] |
|||
}, |
|||
{ |
|||
"text": "Uživatelské rozhraní", |
|||
"items": [ |
|||
{ |
|||
"text": "Správa klientských balíčků", |
|||
"path": "AspNetCore/Client-Side-Package-Management.md" |
|||
}, |
|||
{ |
|||
"text": "Svazování & minifikace", |
|||
"path": "AspNetCore/Bundling-Minification.md" |
|||
}, |
|||
{ |
|||
"text": "Tag pomocníci", |
|||
"path": "AspNetCore/Tag-Helpers/Index.md" |
|||
}, |
|||
{ |
|||
"text": "Widgety", |
|||
"path": "AspNetCore/Widgets.md" |
|||
}, |
|||
{ |
|||
"text": "Motivy", |
|||
"path": "AspNetCore/Theming.md" |
|||
} |
|||
] |
|||
} |
|||
] |
|||
}, |
|||
{ |
|||
"text": "Přístup k datům", |
|||
"path": "Data-Access.md", |
|||
"items": [ |
|||
{ |
|||
"text": "Connection stringy", |
|||
"path": "Connection-Strings.md" |
|||
}, |
|||
{ |
|||
"text": "Poskytovatelé databází", |
|||
"items": [ |
|||
{ |
|||
"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": "Pozadí", |
|||
"items": [ |
|||
{ |
|||
"text": "Úkony na pozadí", |
|||
"path": "Background-Jobs.md", |
|||
"items": [ |
|||
{ |
|||
"text": "Hangfire integrace", |
|||
"path": "Background-Jobs-Hangfire.md" |
|||
}, |
|||
{ |
|||
"text": "RabbitMQ integrace", |
|||
"path": "Background-Jobs-RabbitMq.md" |
|||
} |
|||
] |
|||
} |
|||
] |
|||
}, |
|||
{ |
|||
"text": "Startovací šablony", |
|||
"path": "Startup-Templates/Index.md", |
|||
"items": [ |
|||
{ |
|||
"text": "Aplikace", |
|||
"path": "Startup-Templates/Application.md" |
|||
}, |
|||
{ |
|||
"text": "Modul", |
|||
"path": "Startup-Templates/Module.md" |
|||
} |
|||
] |
|||
}, |
|||
{ |
|||
"text": "Vzorky", |
|||
"items": [ |
|||
{ |
|||
"text": "Mikroslužby demo", |
|||
"path": "Samples/Microservice-Demo.md" |
|||
} |
|||
] |
|||
}, |
|||
{ |
|||
"text": "Moduly aplikace", |
|||
"path": "Modules/Index.md" |
|||
}, |
|||
{ |
|||
"text": "Architektura mikroslužby", |
|||
"path": "Microservice-Architecture.md" |
|||
}, |
|||
{ |
|||
"text": "Testování" |
|||
}, |
|||
{ |
|||
"text": "Noční sestavení", |
|||
"path": "Nightly-Builds.md" |
|||
}, |
|||
{ |
|||
"text": "Průvodce pro přispěvatele", |
|||
"path": "Contribution/Index.md" |
|||
} |
|||
] |
|||
} |
|||
|
Before Width: | Height: | Size: 3.9 KiB |
|
Before Width: | Height: | Size: 43 KiB |
|
Before Width: | Height: | Size: 29 KiB |
|
Before Width: | Height: | Size: 30 KiB |
|
Before Width: | Height: | Size: 11 KiB |
|
Before Width: | Height: | Size: 28 KiB |
|
Before Width: | Height: | Size: 7.4 KiB |
|
Before Width: | Height: | Size: 41 KiB |
|
Before Width: | Height: | Size: 12 KiB |
|
Before Width: | Height: | Size: 28 KiB |
|
Before Width: | Height: | Size: 14 KiB |
|
Before Width: | Height: | Size: 8.6 KiB |
|
Before Width: | Height: | Size: 3.8 KiB |
|
Before Width: | Height: | Size: 63 KiB |
|
Before Width: | Height: | Size: 119 KiB |
|
Before Width: | Height: | Size: 20 KiB |
|
Before Width: | Height: | Size: 21 KiB |
|
Before Width: | Height: | Size: 35 KiB |
|
Before Width: | Height: | Size: 7.5 KiB |
|
Before Width: | Height: | Size: 33 KiB |
|
Before Width: | Height: | Size: 17 KiB |
|
Before Width: | Height: | Size: 10 KiB |
|
Before Width: | Height: | Size: 8.0 KiB |
|
Before Width: | Height: | Size: 5.5 KiB |
|
Before Width: | Height: | Size: 48 KiB |
|
Before Width: | Height: | Size: 45 KiB |
|
Before Width: | Height: | Size: 45 KiB |
|
Before Width: | Height: | Size: 19 KiB |
|
Before Width: | Height: | Size: 32 KiB |
|
Before Width: | Height: | Size: 27 KiB |
|
Before Width: | Height: | Size: 1.8 KiB |
|
Before Width: | Height: | Size: 10 KiB |
Some files were not shown because too many files changed in this diff
Loading…
Reference in new issue