mirror of https://github.com/abpframework/abp.git
Salih
2 years ago
1219 changed files with 10688 additions and 71527 deletions
@ -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 |
|
Before Width: | Height: | Size: 8.9 KiB |
|
Before Width: | Height: | Size: 29 KiB |
|
Before Width: | Height: | Size: 31 KiB |
|
Before Width: | Height: | Size: 2.4 KiB |
|
Before Width: | Height: | Size: 119 KiB |
|
Before Width: | Height: | Size: 57 KiB |
|
Before Width: | Height: | Size: 50 KiB |
|
Before Width: | Height: | Size: 36 KiB |
|
Before Width: | Height: | Size: 8.2 KiB |
|
Before Width: | Height: | Size: 18 KiB |
|
Before Width: | Height: | Size: 6.8 KiB |
|
Before Width: | Height: | Size: 3.8 KiB |
|
Before Width: | Height: | Size: 3.7 KiB |
|
Before Width: | Height: | Size: 26 KiB |
|
Before Width: | Height: | Size: 15 KiB |
|
Before Width: | Height: | Size: 17 KiB |
|
Before Width: | Height: | Size: 3.7 KiB |
|
Before Width: | Height: | Size: 3.7 KiB |
|
Before Width: | Height: | Size: 43 KiB |
|
Before Width: | Height: | Size: 17 KiB |
|
Before Width: | Height: | Size: 2.2 KiB |
|
Before Width: | Height: | Size: 12 KiB |
|
Before Width: | Height: | Size: 30 KiB |
|
Before Width: | Height: | Size: 11 KiB |
|
Before Width: | Height: | Size: 4.8 KiB |
|
Before Width: | Height: | Size: 6.2 KiB |
@ -1,140 +0,0 @@ |
|||||
# Empezando con ABP y una Aplicacion AspNet Core MVC Web |
|
||||
|
|
||||
Este tutorial explica como empezar una aplicacion ABP desde cero usando las dependencias minimas. Uno generalmente desea |
|
||||
empezar con la **[plantilla de inicio](Getting-Started-AspNetCore-MVC-Template.md)**. |
|
||||
|
|
||||
## Crea un Proyecto Nuevo |
|
||||
|
|
||||
1. Crea una Aplicacion Web AspNet Core nueva usando Visual Studio 2022 (17.0.0+): |
|
||||
|
|
||||
 |
|
||||
|
|
||||
2. Configura el nuevo proyecto: |
|
||||
|
|
||||
 |
|
||||
|
|
||||
3. Presione el boton Create: |
|
||||
|
|
||||
 |
|
||||
|
|
||||
## Instale el paquete Volo.Abp.AspNetCore.Mvc |
|
||||
|
|
||||
Volo.Abp.AspNetCore.Mvc es el paquete de integracion con AspNet Core MVC para ABP. Siendo asi, instalalo en su proyecto: |
|
||||
|
|
||||
```` |
|
||||
Install-Package Volo.Abp.AspNetCore.Mvc |
|
||||
```` |
|
||||
|
|
||||
## Crea el primer modulo ABP |
|
||||
|
|
||||
ABP es un marco de referencia modular y require una clase de **inicio (raíz) tipo modulo** derivada de ``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(); |
|
||||
|
|
||||
// Configura la canalización de peticiones HTTP. |
|
||||
if (env.IsDevelopment()) |
|
||||
{ |
|
||||
app.UseExceptionHandler("/Error"); |
|
||||
// El valor por defecto de HSTS es 30 dias. Debes cambiar esto en ambientes productivos. Referencia https://aka.ms/aspnetcore-hsts. |
|
||||
app.UseHsts(); |
|
||||
} |
|
||||
|
|
||||
app.UseHttpsRedirection(); |
|
||||
app.UseStaticFiles(); |
|
||||
app.UseRouting(); |
|
||||
app.UseConfiguredEndpoints(); |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
```` |
|
||||
|
|
||||
``AppModule`` es un buen nombre para el modulo de inicio de una aplicacion. |
|
||||
|
|
||||
Los paquetes de ABP definen clases de tipo modulo y cada modulo puede depender de otro. |
|
||||
En el codigo anterior, el ``AppModule`` depende de el modulo ``AbpAspNetCoreMvcModule`` (definido por el paquete [Volo.Abp.AspNetCore.Mvc](https://www.nuget.org/packages/Volo.Abp.AspNetCore.Mvc)). Es comun agregar el atributo ``DependsOn`` despues de instalar un paquete ABP nuevo. |
|
||||
|
|
||||
En vez de la clase de inicion Startup, estamos configurando una canalizacion de ASP.NET Core en este modulo. |
|
||||
|
|
||||
## La clase Program |
|
||||
|
|
||||
El proximo paso es modificar la clase Program para integrate el sistema de modulos ABP: |
|
||||
|
|
||||
````C# |
|
||||
using BasicAspNetCoreApplication; |
|
||||
|
|
||||
var builder = WebApplication.CreateBuilder(args); |
|
||||
|
|
||||
await builder.Services.AddApplicationAsync<AppModule>(); |
|
||||
|
|
||||
var app = builder.Build(); |
|
||||
|
|
||||
await app.InitializeApplicationAsync(); |
|
||||
await app.RunAsync(); |
|
||||
```` |
|
||||
|
|
||||
``builder.Services.AddApplicationAsync<AppModule>();`` Agrega todos los servicios definidos en todos los modulos empezando desde ``AppModule``. |
|
||||
|
|
||||
``app.InitializeApplicationAsync()`` inicializa y empieza la aplicacion. |
|
||||
|
|
||||
## Ejecutar la Aplicación |
|
||||
|
|
||||
Es todo! Ejecuta la aplicación, debe funcionar como esperado. |
|
||||
|
|
||||
## Uso de Autofac como Marco de Inyección de Dependencia |
|
||||
|
|
||||
Mientras el sistema de Inyección de Dependencia de ASP.NET Core es suficiente para requerimientos basico, [Autofac](https://autofac.org/) proporciona características avanzadas como Inyección de Propiedades e Intercepcion de Metodos, los cuales son necesarios para que ABP pueda llevar a cabo funciones avanzadas. |
|
||||
|
|
||||
El acto de remplazar el sistema DI de ASP.NET Core por Autofac e integrarlo con ABP es facil. |
|
||||
|
|
||||
1. Instala el paquete [Volo.Abp.Autofac](https://www.nuget.org/packages/Volo.Abp.Autofac) |
|
||||
|
|
||||
```` |
|
||||
Install-Package Volo.Abp.Autofac |
|
||||
```` |
|
||||
|
|
||||
2. Agrega la dependencia sobre el modulo ``AbpAutofacModule`` |
|
||||
|
|
||||
````C# |
|
||||
[DependsOn(typeof(AbpAspNetCoreMvcModule))] |
|
||||
[DependsOn(typeof(AbpAutofacModule))] //Agrega la dependencia sobre el modulo ABP Autofac |
|
||||
public class AppModule : AbpModule |
|
||||
{ |
|
||||
... |
|
||||
} |
|
||||
```` |
|
||||
|
|
||||
3. Actualiza `Program.cs` para que use Autofac: |
|
||||
|
|
||||
````C# |
|
||||
using BasicAspNetCoreApplication; |
|
||||
|
|
||||
var builder = WebApplication.CreateBuilder(args); |
|
||||
|
|
||||
builder.Host.UseAutofac(); //Agrega esta linea |
|
||||
|
|
||||
await builder.Services.AddApplicationAsync<AppModule>(); |
|
||||
|
|
||||
var app = builder.Build(); |
|
||||
|
|
||||
await app.InitializeApplicationAsync(); |
|
||||
await app.RunAsync(); |
|
||||
```` |
|
||||
|
|
||||
## Codigo fuente |
|
||||
|
|
||||
Obten el codigo fuente del ejemplo creado en este tutorial de [aqui](https://github.com/abpframework/abp-samples/tree/master/BasicAspNetCoreApplication). |
|
||||
@ -1,31 +0,0 @@ |
|||||
# Documentación de ABP |
|
||||
|
|
||||
ABP es un **marco de desarrollo de código abierto** enfocado en el desarrollo de aplicaciones web basadas en ASP.NET Core, pero tambien soporta el desarrollo de otro tipo de aplicaciones. |
|
||||
|
|
||||
Explora el menú de navegación de la izquierda para profundizar en la documentación. |
|
||||
|
|
||||
## Estado del proyecto |
|
||||
|
|
||||
ABP es la **próxima generación** del marco de desarrollo de código abierto [ASP.NET Boilerplate](https://aspnetboilerplate.com/). Actualmente se encuentra en una fase preliminar y no está listo para su uso en producción. La documentación todavía está en progreso y se encuentra lejos de estar completa. |
|
||||
|
|
||||
Para aplicaciones en fase de producción o que lo vayan a estar en el corto plazo, se sugiere usar el marco de desarrollo [ASP.NET Boilerplate](https://aspnetboilerplate.com/) el cual tiene un completo conjunto de funciones, es maduro, mantenido y actualizado activamente. |
|
||||
|
|
||||
## Primeros pasos |
|
||||
|
|
||||
La manera más facil para iniciar un proyecto con ABP es usar las plantillas de inicio: |
|
||||
|
|
||||
* [Plantilla ASP.NET Core MVC (Razor Pages) UI](Getting-Started-AspNetCore-MVC-Template.md) |
|
||||
* [Plantilla Angular UI](Getting-Started-Angular-Template.md) |
|
||||
|
|
||||
Si quieres iniciar desde cero (con un proyecto vacío), entonces instala manualmente el marco de desarrollo ABP y usa los siguientes tutoriales: |
|
||||
|
|
||||
* [Aplicación de Consola](Getting-Started-Console-Application.md) |
|
||||
* [Aplicación web con ASP.NET Core](Getting-Started-AspNetCore-Application.md) |
|
||||
|
|
||||
## Código fuente |
|
||||
|
|
||||
ABP está hospedado en GitHub. Mira el [código fuente](https://github.com/abpframework/abp). |
|
||||
|
|
||||
## ¿Quieres contribuir? |
|
||||
|
|
||||
ABP es un proyecto de código abierto impulsado por la comunidad. Mira la [guía de contribución](Contribution/Index.md) si quieres formar parte de este proyecto. |
|
||||
|
Before Width: | Height: | Size: 34 KiB |
|
Before Width: | Height: | Size: 119 KiB |
|
Before Width: | Height: | Size: 43 KiB |
@ -1,3 +0,0 @@ |
|||||
Este documento foi movido. |
|
||||
|
|
||||
[Clique para navegar até o documento Auto API Controllers](../API/Auto-API-Controllers.md) |
|
||||
@ -1,3 +0,0 @@ |
|||||
Este documento foi movido. |
|
||||
|
|
||||
[Clique para navegar até o documento de Bundling & Minification do ASP.NET Core MVC](../UI/AspNetCore/Bundling-Minification.md) |
|
||||
@ -1,3 +0,0 @@ |
|||||
Este documento foi movido. |
|
||||
|
|
||||
[Clique para navegar até o documento de Gerenciamento de Pacotes do Lado do Cliente do ASP.NET Core MVC](../UI/AspNetCore/Client-Side-Package-Management.md) |
|
||||
@ -1,3 +0,0 @@ |
|||||
Este documento foi movido. |
|
||||
|
|
||||
[Clique para navegar até o documento Dynamic C# API Clients](../API/Dynamic-CSharp-API-Clients.md) |
|
||||
@ -1,3 +0,0 @@ |
|||||
Este documento foi movido. |
|
||||
|
|
||||
[Clique para navegar até o documento de Formulários Dinâmicos](../../UI/AspNetCore/Tag-Helpers/Dynamic-Forms.md) |
|
||||
@ -1,3 +0,0 @@ |
|||||
Este documento foi movido. |
|
||||
|
|
||||
[Clique para navegar até o documento ABP Tag Helpers](../../UI/AspNetCore/Tag-Helpers/Index.md) |
|
||||
@ -1,3 +0,0 @@ |
|||||
Este documento foi movido. |
|
||||
|
|
||||
[Clique para navegar até o documento de Temas](../UI/AspNetCore/Theming.md) |
|
||||
@ -1,3 +0,0 @@ |
|||||
Este documento foi movido. |
|
||||
|
|
||||
[Clique para navegar até o documento Widgets](../UI/AspNetCore/Widgets.md) |
|
||||
@ -1,3 +0,0 @@ |
|||||
## Dynamic Proxying / Interceptors |
|
||||
|
|
||||
Façam |
|
||||
@ -1,390 +0,0 @@ |
|||||
# Registro de Auditoria |
|
||||
|
|
||||
[Wikipedia](https://en.wikipedia.org/wiki/Audit_trail): "*Um rastro de auditoria (também chamado de **log de auditoria**) é um registro cronológico relevante para a segurança, conjunto de registros e/ou destino e origem de registros que fornecem evidências documentais da sequência de atividades que afetaram a qualquer momento uma operação, procedimento ou evento específico*". |
|
||||
|
|
||||
O ABP Framework fornece um **sistema de registro de auditoria extensível** que automatiza o registro de auditoria por **convenção** e fornece **pontos de configuração** para controlar o nível dos logs de auditoria. |
|
||||
|
|
||||
Um **objeto de log de auditoria** (consulte a seção Objeto de Log de Auditoria abaixo) é tipicamente criado e salvo por solicitação da web. Ele inclui; |
|
||||
|
|
||||
* Detalhes da **solicitação e resposta** (como URL, método Http, informações do navegador, código de status HTTP... etc.). |
|
||||
* **Ações realizadas** (ações do controlador e chamadas de métodos de serviço de aplicação com seus parâmetros). |
|
||||
* **Mudanças de entidade** ocorridas na solicitação da web. |
|
||||
* Informações de **exceção** (se houve um erro durante a execução da solicitação). |
|
||||
* **Duração da solicitação** (para medir o desempenho da aplicação). |
|
||||
|
|
||||
> Os [modelos de inicialização](Startup-Templates/Index.md) são configurados para o sistema de registro de auditoria, o que é adequado para a maioria das aplicações. Use este documento para um controle detalhado sobre o sistema de log de auditoria. |
|
||||
|
|
||||
### Suporte do Provedor de Banco de Dados |
|
||||
|
|
||||
* Totalmente suportado pelo provedor [Entity Framework Core](Entity-Framework-Core.md). |
|
||||
* O log de alterações de entidade não é suportado pelo provedor [MongoDB](MongoDB.md). Outros recursos funcionam conforme o esperado. |
|
||||
|
|
||||
## UseAuditing() |
|
||||
|
|
||||
O middleware `UseAuditing()` deve ser adicionado ao pipeline de solicitações do ASP.NET Core para criar e salvar os logs de auditoria. Se você criou suas aplicações usando [os modelos de inicialização](Startup-Templates/Index.md), ele já está adicionado. |
|
||||
|
|
||||
## AbpAuditingOptions |
|
||||
|
|
||||
`AbpAuditingOptions` é o principal [objeto de opções](Options.md) para configurar o sistema de log de auditoria. Você pode configurá-lo no método `ConfigureServices` do seu [módulo](Module-Development-Basics.md): |
|
||||
|
|
||||
````csharp |
|
||||
Configure<AbpAuditingOptions>(options => |
|
||||
{ |
|
||||
options.IsEnabled = false; //Desativa o sistema de auditoria |
|
||||
}); |
|
||||
```` |
|
||||
|
|
||||
Aqui, uma lista das opções que você pode configurar: |
|
||||
|
|
||||
* `IsEnabled` (padrão: `true`): Uma chave raiz para habilitar ou desabilitar o sistema de auditoria. Outras opções não são usadas se esse valor for `false`. |
|
||||
* `HideErrors` (padrão: `true`): O sistema de log de auditoria oculta e escreve [logs](Logging.md) regulares se ocorrer algum erro ao salvar os objetos de log de auditoria. Se salvar os logs de auditoria for crítico para o seu sistema, defina isso como `false` para lançar uma exceção em caso de ocultação de erros. |
|
||||
* `IsEnabledForAnonymousUsers` (padrão: `true`): Se você deseja escrever logs de auditoria apenas para os usuários autenticados, defina isso como `false`. Se você salvar logs de auditoria para usuários anônimos, verá `null` para os valores de `UserId` desses usuários. |
|
||||
* `AlwaysLogOnException` (padrão: `true`): Se definido como verdadeiro, sempre salva o log de auditoria em caso de exceção/erro sem verificar outras opções (exceto `IsEnabled`, que desativa completamente o registro de auditoria). |
|
||||
* `IsEnabledForIntegrationService` (padrão: `false`): O Registro de Auditoria é desativado para [serviços de integração](Integration-Services.md) por padrão. Defina essa propriedade como `true` para habilitá-la. |
|
||||
* `IsEnabledForGetRequests` (padrão: `false`): As solicitações HTTP GET normalmente não devem fazer nenhuma alteração no banco de dados e o sistema de log de auditoria não salva objetos de log de auditoria para solicitações GET. Defina isso como `true` para habilitá-lo também para as solicitações GET. |
|
||||
* `DisableLogActionInfo` (padrão: `false`): Se definido como verdadeiro, não registrará mais `AuditLogActionInfo`. |
|
||||
* `ApplicationName`: Se várias aplicações estiverem salvando logs de auditoria em um único banco de dados, defina essa propriedade com o nome da sua aplicação, para que você possa distinguir os logs de diferentes aplicações. Se você não definir, ele será definido a partir do valor `IApplicationInfoAccessor.ApplicationName`, que é o nome da assembly de entrada por padrão. |
|
||||
* `IgnoredTypes`: Uma lista de `Type`s a serem ignorados para o registro de auditoria. Se for um tipo de entidade, as alterações para esse tipo de entidades não serão salvas. Esta lista também é usada ao serializar os parâmetros de ação. |
|
||||
* `EntityHistorySelectors`: Uma lista de seletores usados para determinar se um tipo de entidade é selecionado para salvar a alteração da entidade. Consulte a seção abaixo para detalhes. |
|
||||
* `SaveEntityHistoryWhenNavigationChanges` (padrão: `true`): Se definido como verdadeiro, salvará as alterações da entidade no log de auditoria quando houver alterações em propriedades de navegação. |
|
||||
* `Contributors`: Uma lista de implementações de `AuditLogContributor`. Um contribuidor é uma forma de estender o sistema de log de auditoria. Consulte a seção "Contribuidores de Log de Auditoria" abaixo. |
|
||||
* `AlwaysLogSelectors`: Uma lista de seletores para salvar os logs de auditoria para os critérios correspondentes. |
|
||||
|
|
||||
### Seletores de Histórico de Entidade |
|
||||
|
|
||||
Salvar todas as alterações de todas as suas entidades exigiria muito espaço no banco de dados. Por esse motivo, **o sistema de log de auditoria não salva nenhuma alteração para as entidades a menos que você configure explicitamente**. |
|
||||
|
|
||||
Para salvar todas as alterações de todas as entidades, simplesmente use o método de extensão `AddAllEntities()`. |
|
||||
|
|
||||
````csharp |
|
||||
Configure<AbpAuditingOptions>(options => |
|
||||
{ |
|
||||
options.EntityHistorySelectors.AddAllEntities(); |
|
||||
}); |
|
||||
```` |
|
||||
|
|
||||
`options.EntityHistorySelectors` na verdade é uma lista de predicados de tipo. Você pode escrever uma expressão lambda para definir seu filtro. |
|
||||
|
|
||||
O seletor de exemplo abaixo faz o mesmo do método de extensão `AddAllEntities()` definido acima: |
|
||||
|
|
||||
````csharp |
|
||||
Configure<AbpAuditingOptions>(options => |
|
||||
{ |
|
||||
options.EntityHistorySelectors.Add( |
|
||||
new NamedTypeSelector( |
|
||||
"MeuSeletorNome", |
|
||||
type => |
|
||||
{ |
|
||||
if (typeof(IEntity).IsAssignableFrom(type)) |
|
||||
{ |
|
||||
return true; |
|
||||
} |
|
||||
else |
|
||||
{ |
|
||||
return false; |
|
||||
} |
|
||||
} |
|
||||
) |
|
||||
); |
|
||||
}); |
|
||||
```` |
|
||||
|
|
||||
A condição `typeof(IEntity).IsAssignableFrom(type)` será `true` para qualquer classe que implemente a interface `IEntity` (tecnicamente, todas as entidades em sua aplicação). Você pode verificar condicionalmente e retornar `true` ou `false` com base em sua preferência. |
|
||||
|
|
||||
`options.EntityHistorySelectors` é uma forma flexível e dinâmica de selecionar as entidades para o registro de auditoria. Outra forma é usar os atributos `Audited` e `DisableAuditing` por entidade. |
|
||||
|
|
||||
## AbpAspNetCoreAuditingOptions |
|
||||
|
|
||||
`AbpAspNetCoreAuditingOptions` é o [objeto de opções](Options.md) para configurar o registro de auditoria na camada ASP.NET Core. Você pode configurá-lo no método `ConfigureServices` do seu [módulo](Module-Development-Basics.md): |
|
||||
|
|
||||
````csharp |
|
||||
Configure<AbpAspNetCoreAuditingOptions>(options => |
|
||||
{ |
|
||||
options.IgnoredUrls.Add("/produtos"); |
|
||||
}); |
|
||||
```` |
|
||||
|
|
||||
`IgnoredUrls` é a única opção. É uma lista de prefixos de URLs ignorados. No exemplo anterior, todas as URLs que começam com `/produtos` serão ignoradas para o registro de auditoria. |
|
||||
|
|
||||
## Habilitando/Desabilitando o Registro de Auditoria para Serviços |
|
||||
|
|
||||
### Habilitar/Desabilitar para Controladores e Ações |
|
||||
|
|
||||
Todas as ações do controlador são registradas por padrão (consulte `IsEnabledForGetRequests` acima para solicitações GET). |
|
||||
|
|
||||
Você pode usar o `[DisableAuditing]` para desativá-lo para um tipo de controlador específico: |
|
||||
|
|
||||
````csharp |
|
||||
[DisableAuditing] |
|
||||
public class HomeController : AbpController |
|
||||
{ |
|
||||
//... |
|
||||
} |
|
||||
```` |
|
||||
|
|
||||
Use `[DisableAuditing]` para qualquer ação para controlá-la no nível da ação: |
|
||||
|
|
||||
````csharp |
|
||||
public class HomeController : AbpController |
|
||||
{ |
|
||||
[DisableAuditing] |
|
||||
public async Task<ActionResult> Home() |
|
||||
{ |
|
||||
//... |
|
||||
} |
|
||||
|
|
||||
public async Task<ActionResult> OutraAcaoRegistrada() |
|
||||
{ |
|
||||
//... |
|
||||
} |
|
||||
} |
|
||||
```` |
|
||||
|
|
||||
### Habilitar/Desabilitar para Serviços de Aplicação e Métodos |
|
||||
|
|
||||
As chamadas de métodos de [serviço de aplicação](Application-Services.md) também são incluídas no log de auditoria por padrão. Você pode usar o `[DisableAuditing]` no nível do serviço ou do método. |
|
||||
|
|
||||
#### Habilitar/Desabilitar para Outros Serviços |
|
||||
|
|
||||
O registro de auditoria de ação pode ser habilitado para qualquer tipo de classe (registrado e resolvido da [injeção de dependência](Dependency-Injection.md)) enquanto é habilitado apenas para os controladores e os serviços de aplicação por padrão. |
|
||||
|
|
||||
Use `[Audited]` e `[DisableAuditing]` para qualquer classe ou método que precisa ser registrado no log de auditoria. Além disso, sua classe pode (direta ou implicitamente) implementar a interface `IAuditingEnabled` para habilitar o registro de auditoria para essa classe por padrão. |
|
||||
|
|
||||
### Habilitar/Desabilitar para Entidades e Propriedades |
|
||||
|
|
||||
Uma entidade é ignorada no registro de alteração de entidade nos seguintes casos; |
|
||||
|
|
||||
* Se você adicionar um tipo de entidade às `AbpAuditingOptions.IgnoredTypes` (como explicado anteriormente), ele é completamente ignorado no sistema de registro de auditoria. |
|
||||
* Se o objeto não for uma [entidade](Entities.md) (não implementa `IEntity` diretamente ou implicitamente - Todas as entidades implementam essa interface por padrão). |
|
||||
* Se o tipo de entidade não for público. |
|
||||
|
|
||||
Caso contrário, você pode usar `Audited` para habilitar o registro de alteração de entidade para uma entidade: |
|
||||
|
|
||||
````csharp |
|
||||
[Audited] |
|
||||
public class MinhaEntidade : Entity<Guid> |
|
||||
{ |
|
||||
//... |
|
||||
} |
|
||||
```` |
|
||||
|
|
||||
Ou desativá-lo para uma entidade: |
|
||||
|
|
||||
````csharp |
|
||||
[DisableAuditing] |
|
||||
public class MinhaEntidade : Entity<Guid> |
|
||||
{ |
|
||||
//... |
|
||||
} |
|
||||
```` |
|
||||
|
|
||||
Desativar o registro de auditoria pode ser necessário apenas se a entidade estiver sendo selecionada pelos `AbpAuditingOptions.EntityHistorySelectors` que foram explicados anteriormente. |
|
||||
|
|
||||
Você pode desativar o registro de auditoria apenas para algumas propriedades de suas entidades para um controle detalhado sobre o registro de auditoria: |
|
||||
|
|
||||
````csharp |
|
||||
[Audited] |
|
||||
public class MeuUsuario : Entity<Guid> |
|
||||
{ |
|
||||
public string Nome { get; set; } |
|
||||
|
|
||||
public string Email { get; set; } |
|
||||
|
|
||||
[DisableAuditing] //Ignora a Senha no registro de auditoria |
|
||||
public string Senha { get; set; } |
|
||||
} |
|
||||
```` |
|
||||
|
|
||||
O sistema de log de auditoria salvará as alterações para a entidade `MeuUsuario` enquanto ignora a propriedade `Senha`, que pode ser perigosa de salvar por motivos de segurança. |
|
||||
|
|
||||
Em alguns casos, você pode querer salvar apenas algumas propriedades de suas entidades e ignorar todas as outras. Escrever `[DisableAuditing]` para todas as outras propriedades seria tedioso. Em tais casos, use `[Audited]` apenas para as propriedades desejadas e marque a entidade com o atributo `[DisableAuditing]`: |
|
||||
|
|
||||
````csharp |
|
||||
[DisableAuditing] |
|
||||
public class MeuUsuario : Entity<Guid> |
|
||||
{ |
|
||||
[Audited] //Apenas registra a alteração do Nome |
|
||||
public string Nome { get; set; } |
|
||||
|
|
||||
public string Email { get; set; } |
|
||||
|
|
||||
public string Senha { get; set; } |
|
||||
} |
|
||||
```` |
|
||||
## IAuditingStore |
|
||||
|
|
||||
`IAuditingStore` é uma interface usada para salvar os objetos de log de auditoria (explicados abaixo) pelo Framework ABP. Se você precisa salvar os objetos de log de auditoria em um armazenamento de dados personalizado, pode implementar o `IAuditingStore` em sua própria aplicação e substituir usando o [sistema de injeção de dependência](Dependency-Injection.md). |
|
||||
|
|
||||
`SimpleLogAuditingStore` é usado se nenhum armazenamento de auditoria estiver registrado. Ele simplesmente escreve o objeto de auditoria no sistema padrão de [logging](Logging.md). |
|
||||
|
|
||||
[O Módulo de Registro de Auditoria](Modules/Audit-Logging.md) foi configurado nos [modelos de inicialização](Startup-Templates/Index.md) para salvar objetos de log de auditoria em um banco de dados (ele suporta vários provedores de banco de dados). Portanto, na maioria das vezes, você não precisa se preocupar com como o `IAuditingStore` foi implementado e usado. |
|
||||
|
|
||||
## Objeto de Log de Auditoria |
|
||||
|
|
||||
Um **objeto de log de auditoria** é criado para cada **solicitação web** por padrão. Um objeto de log de auditoria pode ser representado pelo seguinte diagrama de relação: |
|
||||
|
|
||||
 |
|
||||
|
|
||||
* **AuditLogInfo**: O objeto raiz com as seguintes propriedades: |
|
||||
* `ApplicationName`: Quando você salva logs de auditoria de diferentes aplicações no mesmo banco de dados, essa propriedade é usada para distinguir os logs das aplicações. |
|
||||
* `UserId`: Id do usuário atual, se o usuário estiver logado. |
|
||||
* `UserName`: Nome do usuário atual, se o usuário estiver logado (esse valor está aqui para não depender do módulo/sistema de identidade para pesquisa). |
|
||||
* `TenantId`: Id do locatário atual, para uma aplicação multi-locatário. |
|
||||
* `TenantName`: Nome do locatário atual, para uma aplicação multi-locatário. |
|
||||
* `ExecutionTime`: O momento em que este objeto de log de auditoria foi criado. |
|
||||
* `ExecutionDuration`: Duração total da execução da solicitação, em milissegundos. Isso pode ser usado para observar o desempenho da aplicação. |
|
||||
* `ClientId`: Id do cliente atual, se o cliente estiver autenticado. Um cliente é geralmente uma aplicação de terceiros que usa o sistema por meio de uma API HTTP. |
|
||||
* `ClientName`: Nome do cliente atual, se disponível. |
|
||||
* `ClientIpAddress`: Endereço IP do cliente/dispositivo do usuário. |
|
||||
* `CorrelationId`: Id de [Correlação Atual](CorrelationId.md). O Id de correlação é usado para relacionar os logs de auditoria escritos por diferentes aplicações (ou microsserviços) em uma única operação lógica. |
|
||||
* `BrowserInfo`: Informações do nome/versão do navegador do usuário atual, se disponível. |
|
||||
* `HttpMethod`: Método HTTP da solicitação atual (GET, POST, PUT, DELETE... etc.). |
|
||||
* `HttpStatusCode`: Código de status da resposta HTTP para esta solicitação. |
|
||||
* `Url`: URL da solicitação. |
|
||||
* **AuditLogActionInfo**: Um log de auditoria de ação é tipicamente uma ação de controlador ou uma chamada de método de [serviço de aplicação](Application-Services.md) durante a solicitação web. Um log de ação pode conter várias ações. Um objeto de ação tem as seguintes propriedades: |
|
||||
* `ServiceName`: Nome do controlador/serviço executado. |
|
||||
* `MethodName`: Nome do método executado do controlador/serviço. |
|
||||
* `Parameters`: Um texto formatado em JSON representando os parâmetros passados para o método. |
|
||||
* `ExecutionTime`: O momento em que este método foi executado. |
|
||||
* `ExecutionDuration`: Duração da execução do método, em milissegundos. Isso pode ser usado para observar o desempenho do método. |
|
||||
* **EntityChangeInfo**: Representa uma alteração de uma entidade nesta solicitação web. Um log de auditoria pode conter zero ou mais alterações de entidade. Uma alteração de entidade tem as seguintes propriedades: |
|
||||
* `ChangeTime`: O momento em que a entidade foi alterada. |
|
||||
* `ChangeType`: Um enum com os seguintes campos: `Criado` (0), `Atualizado` (1) e `Excluído` (2). |
|
||||
* `EntityId`: Id da entidade que foi alterada. |
|
||||
* `EntityTenantId`: Id do locatário a que esta entidade pertence. |
|
||||
* `EntityTypeFullName`: Nome do tipo (classe) da entidade com namespace completo (como *Acme.BookStore.Book* para a entidade Book). |
|
||||
* **EntityPropertyChangeInfo**: Representa uma alteração de uma propriedade de uma entidade. Uma informação de alteração de entidade (explicada acima) pode conter uma ou mais alterações de propriedade com as seguintes propriedades: |
|
||||
* `NewValue`: Novo valor da propriedade. É `null` se a entidade foi excluída. |
|
||||
* `OriginalValue`: Valor antigo/original antes da alteração. É `null` se a entidade foi recém-criada. |
|
||||
* `PropertyName`: O nome da propriedade na classe da entidade. |
|
||||
* `PropertyTypeFullName`: Nome do tipo (classe) da propriedade com namespace completo. |
|
||||
* **Exception**: Um objeto de log de auditoria pode conter zero ou mais exceções. Dessa forma, você pode obter um relatório das solicitações com falha. |
|
||||
* **Comment**: Um valor de string arbitrário para adicionar mensagens personalizadas à entrada de log de auditoria. Um objeto de log de auditoria pode conter zero ou mais comentários. |
|
||||
|
|
||||
Além das propriedades padrão explicadas acima, os objetos `AuditLogInfo`, `AuditLogActionInfo` e `EntityChangeInfo` implementam a interface `IHasExtraProperties`, para que você possa adicionar propriedades personalizadas a esses objetos. |
|
||||
|
|
||||
## Contribuidores de Log de Auditoria |
|
||||
|
|
||||
Você pode estender o sistema de auditoria criando uma classe derivada da classe `AuditLogContributor`, que define os métodos `PreContribute` e `PostContribute`. |
|
||||
|
|
||||
O único contribuidor pré-construído é a classe `AspNetCoreAuditLogContributor`, que define as propriedades relacionadas a uma solicitação HTTP. |
|
||||
|
|
||||
Um contribuidor pode definir propriedades e coleções da classe `AuditLogInfo` para adicionar mais informações. |
|
||||
|
|
||||
Exemplo: |
|
||||
|
|
||||
````csharp |
|
||||
public class MyAuditLogContributor : AuditLogContributor |
|
||||
{ |
|
||||
public override void PreContribute(AuditLogContributionContext context) |
|
||||
{ |
|
||||
var currentUser = context.ServiceProvider.GetRequiredService<ICurrentUser>(); |
|
||||
context.AuditInfo.SetProperty( |
|
||||
"MyCustomClaimValue", |
|
||||
currentUser.FindClaimValue("MyCustomClaim") |
|
||||
); |
|
||||
} |
|
||||
|
|
||||
public override void PostContribute(AuditLogContributionContext context) |
|
||||
{ |
|
||||
context.AuditInfo.Comments.Add("Algum comentário..."); |
|
||||
} |
|
||||
} |
|
||||
```` |
|
||||
|
|
||||
* `context.ServiceProvider` pode ser usado para resolver serviços da [injeção de dependência](Dependency-Injection.md). |
|
||||
* `context.AuditInfo` pode ser usado para acessar o objeto de log de auditoria atual para manipulá-lo. |
|
||||
|
|
||||
Após criar um contribuidor, você deve adicioná-lo à lista `AbpAuditingOptions.Contributors`: |
|
||||
|
|
||||
````csharp |
|
||||
Configure<AbpAuditingOptions>(options => |
|
||||
{ |
|
||||
options.Contributors.Add(new MyAuditLogContributor()); |
|
||||
}); |
|
||||
```` |
|
||||
|
|
||||
## IAuditLogScope & IAuditingManager |
|
||||
|
|
||||
Esta seção explica os serviços `IAuditLogScope` e `IAuditingManager` para casos de uso avançados. |
|
||||
|
|
||||
Um **escopo de log de auditoria** é um [escopo ambiente](Ambient-Context-Pattern.md) que **constrói** e **salva** um objeto de log de auditoria (explicado anteriormente). Por padrão, um escopo de log de auditoria é criado para uma solicitação web pelo Middleware de Log de Auditoria (veja a seção `UseAuditing()` acima). |
|
||||
|
|
||||
### Acesso ao Escopo Atual de Log de Auditoria |
|
||||
|
|
||||
Os contribuidores de log de auditoria, explicados acima, são uma maneira global de manipular o objeto de log de auditoria. É bom se você puder obter um valor de um serviço. |
|
||||
|
|
||||
Se você precisar manipular o objeto de log de auditoria em um ponto arbitrário de sua aplicação, pode acessar o escopo de log de auditoria atual e obter o objeto de log de auditoria atual (independente de como o escopo é gerenciado). Exemplo: |
|
||||
|
|
||||
````csharp |
|
||||
public class MeuServico : ITransientDependency |
|
||||
{ |
|
||||
private readonly IAuditingManager _auditingManager; |
|
||||
|
|
||||
public MeuServico(IAuditingManager auditingManager) |
|
||||
{ |
|
||||
_auditingManager = auditingManager; |
|
||||
} |
|
||||
|
|
||||
public async Task FazerIssoAsync() |
|
||||
{ |
|
||||
var escopoAtualDeLogDeAuditoria = _auditingManager.Current; |
|
||||
if (escopoAtualDeLogDeAuditoria != null) |
|
||||
{ |
|
||||
escopoAtualDeLogDeAuditoria.Log.Comments.Add( |
|
||||
"Executou o método MeuServico.FazerIssoAsync :)" |
|
||||
); |
|
||||
|
|
||||
escopoAtualDeLogDeAuditoria.Log.SetProperty("MinhaPropriedadePersonalizada", 42); |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
```` |
|
||||
|
|
||||
Sempre verifique se `_auditingManager.Current` é nulo ou não, porque é controlado em um escopo externo e você não pode saber se um escopo de log de auditoria foi criado antes de chamar seu método. |
|
||||
|
|
||||
### Criar Manualmente um Escopo de Log de Auditoria |
|
||||
|
|
||||
Raramente você precisa criar manualmente um escopo de log de auditoria, mas se precisar, pode criar um escopo de log de auditoria usando o `IAuditingManager` como no exemplo a seguir: |
|
||||
|
|
||||
````csharp |
|
||||
public class MeuServico : ITransientDependency |
|
||||
{ |
|
||||
private readonly IAuditingManager _auditingManager; |
|
||||
|
|
||||
public MeuServico(IAuditingManager auditingManager) |
|
||||
{ |
|
||||
_auditingManager = auditingManager; |
|
||||
} |
|
||||
|
|
||||
public async Task FazerIssoAsync() |
|
||||
{ |
|
||||
using (var escopoDeAuditoria = _auditingManager.BeginScope()) |
|
||||
{ |
|
||||
try |
|
||||
{ |
|
||||
//Chame outros serviços... |
|
||||
} |
|
||||
catch (Exception ex) |
|
||||
{ |
|
||||
//Adicione exceções |
|
||||
_auditingManager.Current.Log.Exceptions.Add(ex); |
|
||||
throw; |
|
||||
} |
|
||||
finally |
|
||||
{ |
|
||||
//Sempre salve o log |
|
||||
await escopoDeAuditoria.SaveAsync(); |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
```` |
|
||||
|
|
||||
Você pode chamar outros serviços, que podem chamar outros, que podem alterar entidades e assim por diante. Todas essas interações são salvas como um único objeto de log de auditoria no bloco finally. |
|
||||
|
|
||||
## O Módulo de Registro de Auditoria |
|
||||
|
|
||||
O Módulo de Registro de Auditoria basicamente implementa o `IAuditingStore` para salvar os objetos de log de auditoria em um banco de dados. Ele suporta vários provedores de banco de dados. Este módulo é adicionado aos modelos de inicialização por padrão. |
|
||||
|
|
||||
Consulte o documento [Módulo de Registro de Auditoria](Modules/Audit-Logging.md) para mais informações. |
|
||||
@ -1,359 +0,0 @@ |
|||||
# Autorização |
|
||||
|
|
||||
A autorização é usada para verificar se um usuário tem permissão para realizar operações específicas na aplicação. |
|
||||
|
|
||||
O ABP estende a [Autorização do ASP.NET Core](https://docs.microsoft.com/pt-br/aspnet/core/security/authorization/introduction) adicionando **permissões** como [políticas](https://docs.microsoft.com/pt-br/aspnet/core/security/authorization/policies) automáticas e permitindo que o sistema de autorização seja utilizado nos **[serviços de aplicação](Application-Services.md)** também. |
|
||||
|
|
||||
Portanto, todos os recursos de autorização do ASP.NET Core e a documentação são válidos em uma aplicação baseada no ABP. Este documento se concentra nos recursos adicionados ao sistema de autorização do ASP.NET Core. |
|
||||
|
|
||||
## Atributo Authorize |
|
||||
|
|
||||
O ASP.NET Core define o atributo [**Authorize**](https://docs.microsoft.com/pt-br/aspnet/core/security/authorization/simple) que pode ser usado para uma ação, um controlador ou uma página. O ABP permite que você use o mesmo atributo para um [serviço de aplicação](Application-Services.md). |
|
||||
|
|
||||
Exemplo: |
|
||||
|
|
||||
```csharp |
|
||||
using System; |
|
||||
using System.Collections.Generic; |
|
||||
using System.Threading.Tasks; |
|
||||
using Microsoft.AspNetCore.Authorization; |
|
||||
using Volo.Abp.Application.Services; |
|
||||
|
|
||||
namespace Acme.BookStore |
|
||||
{ |
|
||||
[Authorize] |
|
||||
public class AuthorAppService : ApplicationService, IAuthorAppService |
|
||||
{ |
|
||||
public Task<List<AuthorDto>> GetListAsync() |
|
||||
{ |
|
||||
... |
|
||||
} |
|
||||
|
|
||||
[AllowAnonymous] |
|
||||
public Task<AuthorDto> GetAsync(Guid id) |
|
||||
{ |
|
||||
... |
|
||||
} |
|
||||
|
|
||||
[Authorize("BookStore_Author_Create")] |
|
||||
public Task CreateAsync(CreateAuthorDto input) |
|
||||
{ |
|
||||
... |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
``` |
|
||||
|
|
||||
- O atributo `Authorize` obriga o usuário a fazer login na aplicação para usar os métodos do `AuthorAppService`. Portanto, o método `GetListAsync` está disponível apenas para usuários autenticados. |
|
||||
- `AllowAnonymous` suprime a autenticação. Portanto, o método `GetAsync` está disponível para todos, incluindo usuários não autorizados. |
|
||||
- `[Authorize("BookStore_Author_Create")]` define uma política (consulte [autorização baseada em políticas](https://docs.microsoft.com/pt-br/aspnet/core/security/authorization/policies)) que é verificada para autorizar o usuário atual. |
|
||||
|
|
||||
"BookStore_Author_Create" é um nome de política arbitrário. Se você declarar um atributo como esse, o sistema de autorização do ASP.NET Core espera que uma política seja definida anteriormente. |
|
||||
|
|
||||
Você pode, é claro, implementar suas próprias políticas conforme descrito na documentação do ASP.NET Core. Mas para condições simples de verdadeiro/falso, como se uma política foi concedida a um usuário ou não, o ABP define o sistema de permissões, que será explicado na próxima seção. |
|
||||
|
|
||||
## Sistema de Permissões |
|
||||
|
|
||||
Uma permissão é uma política simples que é concedida ou proibida para um usuário, função ou cliente específico. |
|
||||
|
|
||||
### Definindo Permissões |
|
||||
|
|
||||
Para definir permissões, crie uma classe que herde de `PermissionDefinitionProvider`, conforme mostrado abaixo: |
|
||||
|
|
||||
```csharp |
|
||||
using Volo.Abp.Authorization.Permissions; |
|
||||
|
|
||||
namespace Acme.BookStore.Permissions |
|
||||
{ |
|
||||
public class BookStorePermissionDefinitionProvider : PermissionDefinitionProvider |
|
||||
{ |
|
||||
public override void Define(IPermissionDefinitionContext context) |
|
||||
{ |
|
||||
var myGroup = context.AddGroup("BookStore"); |
|
||||
|
|
||||
myGroup.AddPermission("BookStore_Author_Create"); |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
``` |
|
||||
|
|
||||
> O ABP descobre automaticamente essa classe. Nenhuma configuração adicional é necessária! |
|
||||
|
|
||||
> Normalmente, você define essa classe dentro do projeto `Application.Contracts` da sua [aplicação](Startup-Templates/Application.md). O modelo de inicialização já vem com uma classe vazia chamada *YourProjectNamePermissionDefinitionProvider* com a qual você pode começar. |
|
||||
|
|
||||
No método `Define`, você precisa adicionar um **grupo de permissões** ou obter um grupo existente e adicionar **permissões** a esse grupo. |
|
||||
|
|
||||
Quando você define uma permissão, ela se torna utilizável no sistema de autorização do ASP.NET Core como um nome de **política**. Ela também se torna visível na interface do usuário. Veja o diálogo de permissões para uma função: |
|
||||
|
|
||||
 |
|
||||
|
|
||||
- O grupo "BookStore" é mostrado como uma nova guia no lado esquerdo. |
|
||||
- "BookStore_Author_Create" no lado direito é o nome da permissão. Você pode concedê-la ou proibi-la para a função. |
|
||||
|
|
||||
Quando você salva o diálogo, ele é salvo no banco de dados e usado no sistema de autorização. |
|
||||
|
|
||||
> A tela acima está disponível quando você instalou o módulo de identidade, que é usado principalmente para gerenciamento de usuários e funções. Os modelos de inicialização já vêm com o módulo de identidade pré-instalado. |
|
||||
|
|
||||
#### Localizando o Nome da Permissão |
|
||||
|
|
||||
"BookStore_Author_Create" não é um bom nome de permissão para a interface do usuário. Felizmente, os métodos `AddPermission` e `AddGroup` podem receber um `LocalizableString` como segundo parâmetro: |
|
||||
|
|
||||
```csharp |
|
||||
var myGroup = context.AddGroup( |
|
||||
"BookStore", |
|
||||
LocalizableString.Create<BookStoreResource>("BookStore") |
|
||||
); |
|
||||
|
|
||||
myGroup.AddPermission( |
|
||||
"BookStore_Author_Create", |
|
||||
LocalizableString.Create<BookStoreResource>("Permission:BookStore_Author_Create") |
|
||||
); |
|
||||
``` |
|
||||
|
|
||||
Em seguida, você pode definir os textos para as chaves "BookStore" e "Permission:BookStore_Author_Create" no arquivo de localização: |
|
||||
|
|
||||
```json |
|
||||
"BookStore": "Livraria", |
|
||||
"Permission:BookStore_Author_Create": "Criar um novo autor" |
|
||||
``` |
|
||||
|
|
||||
> Para mais informações, consulte a [documentação de localização](Localization.md) sobre o sistema de localização. |
|
||||
|
|
||||
A interface do usuário localizada será como mostrado abaixo: |
|
||||
|
|
||||
 |
|
||||
|
|
||||
#### Multi-Tenancy |
|
||||
|
|
||||
O ABP suporta [multi-tenancy](Multi-Tenancy.md) como um recurso de primeira classe. Você pode definir a opção de lado de multi-tenancy ao definir uma nova permissão. Ela pode ter um dos três valores definidos abaixo: |
|
||||
|
|
||||
- **Host**: A permissão está disponível apenas para o lado do host. |
|
||||
- **Tenant**: A permissão está disponível apenas para o lado do tenant. |
|
||||
- **Ambos** (padrão): A permissão está disponível tanto para o lado do tenant quanto para o lado do host. |
|
||||
|
|
||||
> Se sua aplicação não é multi-tenant, você pode ignorar essa opção. |
|
||||
|
|
||||
Para definir a opção de lado de multi-tenancy, passe para o terceiro parâmetro do método `AddPermission`: |
|
||||
|
|
||||
```csharp |
|
||||
myGroup.AddPermission( |
|
||||
"BookStore_Author_Create", |
|
||||
LocalizableString.Create<BookStoreResource>("Permission:BookStore_Author_Create"), |
|
||||
multiTenancySide: MultiTenancySides.Tenant //defina o lado de multi-tenancy! |
|
||||
); |
|
||||
``` |
|
||||
|
|
||||
#### Habilitar/Desabilitar Permissões |
|
||||
|
|
||||
Uma permissão está habilitada por padrão. É possível desabilitar uma permissão. Uma permissão desabilitada será proibida para todos. Você ainda pode verificar a permissão, mas ela sempre retornará proibida. |
|
||||
|
|
||||
Exemplo de definição: |
|
||||
|
|
||||
````csharp |
|
||||
myGroup.AddPermission("Author_Management", isEnabled: false); |
|
||||
```` |
|
||||
|
|
||||
Normalmente, você não precisa definir uma permissão desabilitada (a menos que queira desabilitar temporariamente um recurso da sua aplicação). No entanto, você pode querer desabilitar uma permissão definida em um módulo dependente. Dessa forma, você pode desabilitar a funcionalidade relacionada à aplicação. Consulte a seção "*Alterando as Definições de Permissão de um Módulo Dependente*" abaixo para um exemplo de uso. |
|
||||
|
|
||||
> Observação: Verificar uma permissão não definida lançará uma exceção, enquanto verificar uma permissão desabilitada simplesmente retornará proibida (falso). |
|
||||
|
|
||||
#### Permissões Filhas |
|
||||
|
|
||||
Uma permissão pode ter permissões filhas. Isso é especialmente útil quando você deseja criar uma árvore de permissões hierárquica, onde uma permissão pode ter permissões secundárias adicionais que estão disponíveis apenas se a permissão pai for concedida. |
|
||||
|
|
||||
Exemplo de definição: |
|
||||
|
|
||||
```csharp |
|
||||
var authorManagement = myGroup.AddPermission("Author_Management"); |
|
||||
authorManagement.AddChild("Author_Management_Create_Books"); |
|
||||
authorManagement.AddChild("Author_Management_Edit_Books"); |
|
||||
authorManagement.AddChild("Author_Management_Delete_Books"); |
|
||||
``` |
|
||||
|
|
||||
O resultado na interface do usuário é mostrado abaixo (provavelmente você desejará localizar as permissões para sua aplicação): |
|
||||
|
|
||||
 |
|
||||
|
|
||||
Para o código de exemplo, é assumido que uma função/usuário com a permissão "Author_Management" concedida pode ter permissões adicionais. Em seguida, um serviço de aplicação típico que verifica permissões pode ser definido como mostrado abaixo: |
|
||||
|
|
||||
```csharp |
|
||||
[Authorize("Author_Management")] |
|
||||
public class AuthorAppService : ApplicationService, IAuthorAppService |
|
||||
{ |
|
||||
public Task<List<AuthorDto>> GetListAsync() |
|
||||
{ |
|
||||
... |
|
||||
} |
|
||||
|
|
||||
public Task<AuthorDto> GetAsync(Guid id) |
|
||||
{ |
|
||||
... |
|
||||
} |
|
||||
|
|
||||
[Authorize("Author_Management_Create_Books")] |
|
||||
public Task CreateAsync(CreateAuthorDto input) |
|
||||
{ |
|
||||
... |
|
||||
} |
|
||||
|
|
||||
[Authorize("Author_Management_Edit_Books")] |
|
||||
public Task UpdateAsync(CreateAuthorDto input) |
|
||||
{ |
|
||||
... |
|
||||
} |
|
||||
|
|
||||
[Authorize("Author_Management_Delete_Books")] |
|
||||
public Task DeleteAsync(CreateAuthorDto input) |
|
||||
{ |
|
||||
... |
|
||||
} |
|
||||
} |
|
||||
``` |
|
||||
|
|
||||
- `GetListAsync` e `GetAsync` estarão disponíveis para usuários se a permissão `Author_Management` for concedida. |
|
||||
- Outros métodos requerem permissões adicionais. |
|
||||
|
|
||||
### Substituindo uma Permissão por uma Política Personalizada |
|
||||
|
|
||||
Se você definir e registrar uma política no sistema de autorização do ASP.NET Core com o mesmo nome de uma permissão, sua política substituirá a permissão existente. Isso é uma maneira poderosa de estender a autorização para um módulo pré-construído que você está usando em sua aplicação. |
|
||||
|
|
||||
Consulte o documento [autorização baseada em políticas](https://docs.microsoft.com/pt-br/aspnet/core/security/authorization/policies) para aprender como definir uma política personalizada. |
|
||||
|
|
||||
### Alterando as Definições de Permissão de um Módulo Dependente |
|
||||
|
|
||||
Uma classe derivada de `PermissionDefinitionProvider` (assim como o exemplo acima) também pode obter definições de permissão existentes (definidas pelos [módulos](Module-Development-Basics.md) dependentes) e alterar suas definições. |
|
||||
|
|
||||
Exemplo: |
|
||||
|
|
||||
````csharp |
|
||||
context |
|
||||
.GetPermissionOrNull(IdentityPermissions.Roles.Delete) |
|
||||
.IsEnabled = false; |
|
||||
```` |
|
||||
|
|
||||
Quando você escreve esse código dentro do seu provedor de definição de permissão, ele encontra a permissão de "exclusão de função" do [Módulo de Identidade](Modules/Identity.md) e desabilita a permissão, para que ninguém possa excluir uma função na aplicação. |
|
||||
|
|
||||
> Dica: É melhor verificar o valor retornado pelo método `GetPermissionOrNull`, pois ele pode retornar nulo se a permissão fornecida não foi definida. |
|
||||
|
|
||||
### Provedores de Valor de Permissão |
|
||||
|
|
||||
O sistema de verificação de permissões é extensível. Qualquer classe derivada de `PermissionValueProvider` (ou que implemente `IPermissionValueProvider`) pode contribuir para a verificação de permissões. Existem três provedores de valor predefinidos: |
|
||||
|
|
||||
- `UserPermissionValueProvider` verifica se o usuário atual tem a permissão concedida. Ele obtém o ID do usuário das reivindicações atuais. O nome da reivindicação do usuário é definido pela propriedade estática `AbpClaimTypes.UserId`. |
|
||||
- `RolePermissionValueProvider` verifica se algum dos papéis do usuário atual tem a permissão concedida. Ele obtém os nomes dos papéis das reivindicações atuais. O nome das reivindicações de papéis é definido pela propriedade estática `AbpClaimTypes.Role`. |
|
||||
- `ClientPermissionValueProvider` verifica se o cliente atual tem a permissão concedida. Isso é especialmente útil em uma interação máquina a máquina, onde não há usuário atual. Ele obtém o ID do cliente das reivindicações atuais. O nome da reivindicação do cliente é definido pela propriedade estática `AbpClaimTypes.ClientId`. |
|
||||
|
|
||||
Você pode estender o sistema de verificação de permissões definindo seu próprio provedor de valor de permissão. |
|
||||
|
|
||||
Exemplo: |
|
||||
|
|
||||
```csharp |
|
||||
public class SystemAdminPermissionValueProvider : PermissionValueProvider |
|
||||
{ |
|
||||
public SystemAdminPermissionValueProvider(IPermissionStore permissionStore) |
|
||||
: base(permissionStore) |
|
||||
{ |
|
||||
} |
|
||||
|
|
||||
public override string Name => "SystemAdmin"; |
|
||||
|
|
||||
public async override Task<PermissionGrantResult> |
|
||||
CheckAsync(PermissionValueCheckContext context) |
|
||||
{ |
|
||||
if (context.Principal?.FindFirst("User_Type")?.Value == "SystemAdmin") |
|
||||
{ |
|
||||
return PermissionGrantResult.Granted; |
|
||||
} |
|
||||
|
|
||||
return PermissionGrantResult.Undefined; |
|
||||
} |
|
||||
} |
|
||||
``` |
|
||||
|
|
||||
Esse provedor permite que todas as permissões sejam concedidas a um usuário com uma reivindicação `User_Type` que tenha o valor `SystemAdmin`. É comum usar as reivindicações atuais e o `IPermissionStore` em um provedor de valor de permissão. |
|
||||
|
|
||||
Um provedor de valor de permissão deve retornar um dos seguintes valores do método `CheckAsync`: |
|
||||
|
|
||||
- `PermissionGrantResult.Granted` é retornado para conceder a permissão ao usuário. Se qualquer um dos provedores retornar `Granted`, o resultado será `Granted`, se nenhum outro provedor retornar `Prohibited`. |
|
||||
- `PermissionGrantResult.Prohibited` é retornado para proibir a permissão ao usuário. Se qualquer um dos provedores retornar `Prohibited`, o resultado será sempre `Prohibited`. Não importa o que os outros provedores retornem. |
|
||||
- `PermissionGrantResult.Undefined` é retornado se esse provedor de valor de permissão não puder decidir sobre o valor da permissão. Retorne isso para permitir que outros provedores verifiquem a permissão. |
|
||||
|
|
||||
Uma vez que um provedor é definido, ele deve ser adicionado às `AbpPermissionOptions`, como mostrado abaixo: |
|
||||
|
|
||||
```csharp |
|
||||
Configure<AbpPermissionOptions>(options => |
|
||||
{ |
|
||||
options.ValueProviders.Add<SystemAdminPermissionValueProvider>(); |
|
||||
}); |
|
||||
``` |
|
||||
|
|
||||
### Armazenamento de Permissões |
|
||||
|
|
||||
`IPermissionStore` é a única interface que precisa ser implementada para ler o valor das permissões de uma fonte de persistência, geralmente um sistema de banco de dados. O módulo de gerenciamento de permissões a implementa e é pré-instalado no modelo de inicialização da aplicação. Consulte a [documentação do módulo de gerenciamento de permissões](Modules/Permission-Management.md) para obter mais informações. |
|
||||
|
|
||||
### AlwaysAllowAuthorizationService |
|
||||
|
|
||||
`AlwaysAllowAuthorizationService` é uma classe usada para ignorar o serviço de autorização. Geralmente é usado em testes de integração, onde você pode querer desabilitar o sistema de autorização. |
|
||||
|
|
||||
Use o método de extensão `IServiceCollection.AddAlwaysAllowAuthorization()` para registrar o `AlwaysAllowAuthorizationService` no sistema de [injeção de dependência](Dependency-Injection.md): |
|
||||
|
|
||||
```csharp |
|
||||
public override void ConfigureServices(ServiceConfigurationContext context) |
|
||||
{ |
|
||||
context.Services.AddAlwaysAllowAuthorization(); |
|
||||
} |
|
||||
``` |
|
||||
|
|
||||
Isso já é feito para testes de integração do modelo de inicialização. |
|
||||
|
|
||||
### Fábrica de Claims Principal |
|
||||
|
|
||||
As reivindicações são elementos importantes da autenticação e autorização. O ABP usa o serviço `IAbpClaimsPrincipalFactory` para criar reivindicações na autenticação. Esse serviço foi projetado para ser extensível. Se você precisar adicionar suas próprias reivindicações ao ticket de autenticação, poderá implementar `IAbpClaimsPrincipalContributor` em sua aplicação. |
|
||||
|
|
||||
**Exemplo: Adicionar uma reivindicação `SocialSecurityNumber` e obtê-la:** |
|
||||
|
|
||||
```csharp |
|
||||
public class SocialSecurityNumberClaimsPrincipalContributor : IAbpClaimsPrincipalContributor, ITransientDependency |
|
||||
{ |
|
||||
public async Task ContributeAsync(AbpClaimsPrincipalContributorContext context) |
|
||||
{ |
|
||||
var identity = context.ClaimsPrincipal.Identities.FirstOrDefault(); |
|
||||
var userId = identity?.FindUserId(); |
|
||||
if (userId.HasValue) |
|
||||
{ |
|
||||
var userService = context.ServiceProvider.GetRequiredService<IUserService>(); //Seu serviço personalizado |
|
||||
var socialSecurityNumber = await userService.GetSocialSecurityNumberAsync(userId.Value); |
|
||||
if (socialSecurityNumber != null) |
|
||||
{ |
|
||||
identity.AddClaim(new Claim("SocialSecurityNumber", socialSecurityNumber)); |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
|
|
||||
public static class CurrentUserExtensions |
|
||||
{ |
|
||||
public static string GetSocialSecurityNumber(this ICurrentUser currentUser) |
|
||||
{ |
|
||||
return currentUser.FindClaimValue("SocialSecurityNumber"); |
|
||||
} |
|
||||
} |
|
||||
``` |
|
||||
|
|
||||
> Se você estiver usando o Identity Server, adicione suas reivindicações a `RequestedClaims` de `AbpClaimsServiceOptions`. |
|
||||
|
|
||||
```csharp |
|
||||
Configure<AbpClaimsServiceOptions>(options => |
|
||||
{ |
|
||||
options.RequestedClaims.AddRange(new[]{ "SocialSecurityNumber" }); |
|
||||
}); |
|
||||
``` |
|
||||
|
|
||||
## Veja também |
|
||||
|
|
||||
* [Módulo de Gerenciamento de Permissões](Modules/Permission-Management.md) |
|
||||
* [API de Autenticação JavaScript do ASP.NET Core MVC / Razor Pages](UI/AspNetCore/JavaScript-API/Auth.md) |
|
||||
* [Gerenciamento de Permissões na Interface do Usuário Angular](UI/Angular/Permission-Management.md) |
|
||||
* [Tutorial em vídeo](https://abp.io/video-courses/essentials/authorization)</source> |
|
||||
@ -1,3 +0,0 @@ |
|||||
## AutoMapper Integration |
|
||||
|
|
||||
Façam |
|
||||
@ -1,3 +0,0 @@ |
|||||
# Hangfire Background Job Manager |
|
||||
|
|
||||
Façam |
|
||||
Some files were not shown because too many files changed in this diff
Loading…
Reference in new issue