Devprime | Documentação – Arquitetura de software

Features: Pipeline

Mon, 01 Jan 0001 00:00:00 +0000

Introdução ao Devprime Pipeline `Dp.Pipeline()`

A tecnologia do Devprime Pipeline é usada em várias etapas do fluxo da aplicação, conforme demonstrado na imagem abaixo desde a recepção de eventos nos Driving Adapters, na camada de Application, no Domain e nos Handlers e depois nos Driven Adapters. É importante observar que, devido à execução paralela de processos, o fluxo do Devprime Pipeline pode estar em estágios diferentes em momentos distintos.

Devprime Pipeline integrado ao serviço de aplicação
A integração do Devprime Pipeline está representada no código abaixo por meio do bloco Dp.Pipeline(). No momento que a aplicação recebe um POST HTTP é pelo Adapter Web, ele é encaminhado para o serviço de aplicação, que preenche o Aggregate Root order. Em seguida, ele é anexado ao Devprime Pipeline usando o comando Dp.Attach(), e o fluxo é direcionado para o método Add do Aggregate Root Order.

// Appplication Services
public void Add(Model.Order command)
    {
        Dp.Pipeline(Execute: () =>
        {
            var order = command.ToDomain();
            Dp.Attach(order);
            order.Add();
        });
    }

Devprime Pipeline integrado ao Domain / Aggregate Root
O Devprime Pipeline oferece recursos incríveis no domínio, preservando o isolamento das regras de negócio. Isso permite que eventos de negócios sejam executados externamente, conforme demonstrado no exemplo abaixo onde o Dp.Pipeline() é inicializado e o objeto de negócio “Items” é anexado ao Devprime Pipeline usando o método Dp.Attach(). Em seguida, os parâmetros de inicialização do novo Aggregate Root são configurados e um evento de domínio chamado CreateOrder() é disparado com o método Dp.ProcessEvent<bool>(new CreateOrder()).

Este evento será processado em um Event Handler externo ao domínio, que pode contém uma implementação para gravar no banco de dados usando o Adapter de State. Em seguida, ele retorna um resultado, que neste contexto é automaticamente tipado como um “bool”.

Conforme o resultado, um novo evento de domínio OrderCreated() pode ser disparado usando o método Dp.ProcessEvent(new OrderCreated()), que será tratado por um handler externo ao domínio para comunicação com o Adapter de Stream e emissão de um evento no RabbitMQ/Kafka e outros"

Código de negócio dentro do Aggregate Root

// Business code inside Aggregate Root
public virtual void Add()
    {
        Dp.Pipeline(Execute: () =>
        {
            Dp.Attach(Items);
            ValidFields();
            ID = Guid.NewGuid();
            IsNew = true;
            var success = Dp.ProcessEvent<bool>(new CreateOrder());
            if (success)
            {
                Dp.ProcessEvent(new OrderCreated());
            }
        });
    }

No exemplo abaixo, apresentamos um resumo da classe CreateOrderEventHandler(), onde, na linha 4, dentro do Handler, é possível recuperar o Aggregate Root originador desse evento de domínio e, em seguida, encaminhar o fluxo de persistência para o Adapter de State.

Um ponto valioso nessa abordagem é que, para a pessoa desenvolvedora, o Adapter de State é o único local que se relaciona com o banco de dados.

// Event Handler CreateOrderEventHandler()
    public override dynamic Handle(CreateOrder createOrder)
    {
        var order = createOrder.Get<Domain.Aggregates.Order.Order>();
        return Dp.State.Order.Add(order);
    }

No exemplo abaixo apresentamos um resumo da classe OrderCreatedEventHandler() onde, na linha 5, dentro do Handler, é possível recuperar o Aggregate Root originador desse evento de domínio. Em seguida, preenche-se um envelope chamado OrderCreatedEventDTO() com os dados que serão enviados no evento pelo Stream. Na linha 12, aciona-se o Adapter de Stream para realizar o envio.

Um ponto valioso nessa abordagem é que, para a pessoa desenvolvedora, a tecnologia de Stream utilizada para a comunicação é transparente.

// Event Handler OrderCreatedEventHandler()
    public override dynamic Handle(OrderCreated orderCreated)
    {
        var success = false;
        var order = orderCreated.Get<Domain.Aggregates.Order.Order>();
        var destination = Dp.Settings.Default("stream.orderevents");
        var eventName = "OrderCreated";
        var eventData = new OrderCreatedEventDTO()
        {ID = order.ID, CustomerName = order.CustomerName,
        CustomerTaxID = order.CustomerTaxID,
        Total = order.Total};
        Dp.Stream.Send(destination, eventName, eventData);
        success = true;
        return success;
    }

Devprime Pipeline integrado no repositório
Devprime Pipeline também está presente na utilização dentro do repositório no Adapter de State, que executa a interação direta com o banco de dados, conforme demonstrado neste contexto, utilizando as classes do MongoDB ou outras tecnologias suportadas nativamente na Plataforma Devprime ou por meio de Extensões.

// State Adapter
public bool Add(Domain.Aggregates.Order.Order order)
    {
        var result = Dp.Pipeline(ExecuteResult: (stateContext) =>
        {
            var state = new ConnectionMongo(stateContext, Dp);
            var _order = ToState(order);
            state.Order.InsertOne(_order);
            return true;
        });
        if (result is null)
            return false;
        return result;
    }

Explorando os Logs automáticos
Uma característica importante em qualquer aplicação moderna é a observabilidade por meio de Logs, Trace e Metrics. Abaixo, podemos acompanhar um resumo de todos os processos orquestrados pelo Devprime Pipeline e a sua integração com o Adapter de Observability, que cuida do processo de exibição.

# Receiving a POST
[INF][Web]["HTTP"][Order][POST /v1/order]
[Origin "https://localhost:5001/swagger/index.html"]
[RID 2227febe-74b7-4e7a-83c9-ba63bf6b6448]
[TID 2227febe-74b7-4e7a-83c9-ba63bf6b6448]

# Processing in Application Services
[INF][Application][OrderService][Add]
[RID 2227febe-74b7-4e7a-83c9-ba63bf6b6448]
[TID 2227febe-74b7-4e7a-83c9-ba63bf6b6448]

# Processing in Aggregate root
[INF][Domain][Order][Add]
[RID 2227febe-74b7-4e7a-83c9-ba63bf6b6448]
[TID 2227febe-74b7-4e7a-83c9-ba63bf6b6448]

# Emitting Domain Event
[INF][Domain][Order][ProcessEvent]["CreateOrder"]
[RID 2227febe-74b7-4e7a-83c9-ba63bf6b6448]
[TID 2227febe-74b7-4e7a-83c9-ba63bf6b6448]

# Processing in Handler
[INF][Application][EventHandler]
["CreateOrderEventHandler"][Event]["CreateOrder"]
[RID 2227febe-74b7-4e7a-83c9-ba63bf6b6448]
[TID 2227febe-74b7-4e7a-83c9-ba63bf6b6448]

# # Processing in Adapter State
[INF][State][Type "MongoDB"][Alias "State1"]
[Initialize][OrderRepository][Add]
[RID 2227febe-74b7-4e7a-83c9-ba63bf6b6448]
[TID 2227febe-74b7-4e7a-83c9-ba63bf6b6448]

[INF][State][Type "MongoDB"][Alias "State1"]
[Complete][OrderRepository][Add][Duration 36.8282ms]
[RID 2227febe-74b7-4e7a-83c9-ba63bf6b6448]
[TID 2227febe-74b7-4e7a-83c9-ba63bf6b6448]

# Emitting Domain Event (OrderCreated)
[INF][Domain][Order][ProcessEvent]["OrderCreated"]
[RID 2227febe-74b7-4e7a-83c9-ba63bf6b6448]
[TID 2227febe-74b7-4e7a-83c9-ba63bf6b6448]|

# Processing in Handler (OrderCreated)
[INF][Application][EventHandler]
["OrderCreatedEventHandler"][Event]["OrderCreated"]
[RID 2227febe-74b7-4e7a-83c9-ba63bf6b6448]
[TID 2227febe-74b7-4e7a-83c9-ba63bf6b6448]

# Processing in Adapter Stream
[INF][Stream][Type "RabbitMQ"][Alias "Stream1"]
[Out][Event]["OrderCreated"]["Delivered"]["orderevents"]
["{\"Id\":\"08c38a8f-8df6-41fb-9b58-2b5c4f3da14d\",
\"CorrelationId\":\"2227febe-74b7-4e7a-83c9-ba63bf6b6448\",
\"TraceId\":\"2227febe-74b7-4e7a-83c9-ba63bf6b6448\",
\"AppId\":\"49d66a15-943b-4847-bdd0-258e3fe23927\",
\"AppName\":\"ms-order\",\"TenantID\":\"\",
\"TenantUserID\":\"\",\"Version\":1,
\"Name\":\"OrderCreated\",\"CreationDate\":
\"2023-09-05T16:37:25.0761355-03:00\",\"Payload\":
{\"ID\":\"8fc530f0-8fc6-4c89-987b-33fc1ea9861c\",
\"CustomerName\":\"Ramon\",\"CustomerTaxID\":
\"string\",\"Total\":0}}"]
[RID 2227febe-74b7-4e7a-83c9-ba63bf6b6448]
[TID 2227febe-74b7-4e7a-83c9-ba63bf6b6448]

Explore outras tecnologias relacionadas

Features: App

Mon, 01 Jan 0001 00:00:00 +0000

Explorando o Devprime App

O projeto Devprime App disponibiliza alguns arquivos principais, como o App.cs, App.csproj, appsettings.json e GlobalUsings.cs, conforme apresentado na imagem.

Esses arquivos são responsáveis pelas definições de inicialização da aplicação, configuração da inversão de dependência, configurações iniciais do app.net, Swagger, segurança e, principalmente, pelos parâmetros de cada adapter, que são tratados em detalhes na seção de Configurações da documentação.

Explorando o arquivo `App.cs`

O arquivo App.cs contém as implementações fundamentais para a inicialização da aplicação e segue um critério de ordem padrão de processamento do ASP.NET. Um ponto importante nesse contexto é a criação do Builder e do Run, assim como as injeções de dependência que conectam todo o projeto de arquitetura da aplicação.

o nome da applicação ou microsserviço é definido nesse momento na linha 23 DpApp(builder).Run("my-microsservices,(app)) e foi definindo automáticamente quando se criou o novo microsserviço utilizando o comando dp new do Devprime CLI.

// Application Builder
var builder = WebApplication.CreateBuilder(args);

// Adding records for dependency injection. 
// This block is modified  when you run the
// dp init command to include new classes.

builder.Services.AddScoped<IPaymentRepository, PaymentRepository>();
builder.Services.AddScoped<IPaymentService, PaymentService>();
builder.Services.AddScoped<IPaymentState, PaymentState>();
builder.Services.AddMvc(o =>
{
    o.EnableEndpointRouting = false;
});

//Registering Devprime Adapters
builder.Services.AddScoped<IExtensions, Extensions>();
builder.Services.AddScoped<IEventStream, EventStream>();
builder.Services.AddScoped<IEventHandler,
Application.EventHandlers.EventHandler>();

// Application Run
await new DpApp(builder).Run("my-microsservices", (app) =>
{

    //The first stage of middleware registration
    app.UseRouting(); //Routes
    app.UseAuthentication(); //Security
    DpApp.UseDevPrimeSwagger(app); //Swagger
    app.UseAuthorization();//Security
    app.MapControllerRoute(name: "default", pattern:
    "{controller=Home}/{action=Index}/{id?}");//Routes

}, (builder) =>
{
    //The second stage of middleware registration
    DpApp.AddDevPrime(builder.Services);//Accelerators
    DpApp.AddDevPrimeSwagger(builder.Services);//Swagger
    DpApp.AddDevPrimeSecurity(builder.Services);//Security
});

Explorando o arquivo `App.csproj`

O arquivo App.csproj traz as dependências para os outros projetos “Adapters” e “Core” que fazem parte da arquitetura do software, bem como para o componente devprime.stack.app da Devprime Stack, que possui comportamentos inteligentes que atendem ao contexto do “App”.

<Project Sdk="Microsoft.NET.Sdk.Web">
	<PropertyGroup>
		<TargetFramework>net7.0</TargetFramework>
		<Version>1.0.0.0</Version>
	</PropertyGroup>
	<ItemGroup>
		<ProjectReference Include=
        "..\Adapters\Services\DevPrime.Services.csproj" />
		<ProjectReference Include=
        "..\Adapters\State\DevPrime.State.csproj" />
		<ProjectReference Include=
        "..\Adapters\Extensions\DevPrime.Extensions.csproj" />
		<ProjectReference Include=
        "..\Adapters\Stream\DevPrime.Stream.csproj" />
		<ProjectReference Include=
        "..\Adapters\Web\DevPrime.Web.csproj" />
		<ProjectReference Include=
        "..\Adapters\Observability\DevPrime.Observability.csproj" />
		<ProjectReference Include=
        "..\Adapters\AppCenter\DevPrime.AppCenter.csproj" />
		<ProjectReference Include=
        "..\Adapters\HealthCheck\DevPrime.HealthCheck.csproj" />
		<ProjectReference Include=
        "..\Core\Application\Application.csproj" />
		<ProjectReference Include=
        "..\Core\Domain\Domain.csproj" />
	</ItemGroup>
	<ItemGroup>
    <PackageReference Include=
    "devprime.stack.app" Version="7.0.50" />
	</ItemGroup>
</Project>

Essa é uma implementação padrão, e não há necessidade de modificar a estrutura, a menos que você queira ajustar os seguintes itens:

Tópico	Descrição
TargetFramework	Versão do .NET e presente em todos os projetos
Version	Atualize o ID da versão pelo DevOps
PackageReference	Referência ao contexto do Devprime Stack

O comando dp stack, fornecido pelo Devprime CLI, deve ser utilizado pela pessoa desenvolvedora para atualizar automaticamente a referência do Devprime em todos os projetos.

Explorando o projeto Devprime `GlobalUsings.cs`

A estratégia do C# para organizar de forma global os namespaces utilizados no projeto e permite que você atualize manualmente ou usando o comando dp init do Devprime CLI, se necessário.

global using DevPrime.Stream;
global using DevPrime.Stack.Foundation.Stream;
global using DevPrime.Stack.Foundation;
global using DevPrime.Stack.App.Load;
global using Microsoft.AspNetCore.Builder;
global using Microsoft.Extensions.DependencyInjection;
global using DevPrime.Extensions;
global using Application.Interfaces.Adapters.Extensions;
global using Application.Interfaces.Adapters.State;
global using Application.Interfaces.Services;
global using Application.Services.Payment;
global using DevPrime.State.Repositories.Payment;
global using DevPrime.State.States;

Explorando o arquivo `appsettings.json`

A plataforma Devprime disponibiliza a possibilidade de customização por meio do arquivo de configuração, que, no ambiente de desenvolvimento, está no projeto Devprime APP e inclui itens como: APP, Web, Stream, Observability, Security, State, Services e Custom.

Acompanhe um exemplo resumido do arquivo appsettings.json. Você pode explorar de forma detalhada na seção de configurações e obter mais detalhes sobre os parâmetros de customização.

{
  "DevPrime_App": {},
  "DevPrime_Web": {},
  "DevPrime_Stream": {},
  "DevPrime_Observability": {},
  "DevPrime_Security": {},
  "DevPrime_Services": {},
  "DevPrime_State": {},
  "DevPrime_Custom": {}
}

Configurações	Detalhes
APP	Parâmetros principais da aplicação
Web	Parâmetros do Adapter Web
Stream	Parâmetros do Adapter Stream
Observability	Parâmetros do Adapter Observability
Security	Parâmetros do Adapter Security
State	Parâmetros do Adapter State
Services	Parâmetros do Adapter Services
Custom	Parâmetros personalizados para a aplicação

Explore outras tecnologias relacionadas

Customizando as configurações do microsserviço

Devprime | Documentação – Arquitetura de software

Features: Pipeline

Introdução ao Devprime Pipeline Dp.Pipeline()

Features: App

Explorando o Devprime App

Explorando o arquivo App.cs

Explorando o arquivo App.csproj

Explorando o projeto Devprime GlobalUsings.cs

Explorando o arquivo appsettings.json

Introdução ao Devprime Pipeline `Dp.Pipeline()`

Explorando o arquivo `App.cs`

Explorando o arquivo `App.csproj`

Explorando o projeto Devprime `GlobalUsings.cs`

Explorando o arquivo `appsettings.json`