Eaf.Middleware.Web.Core 9.1.0

Eaf.Middleware.Web.Core

Descrição Técnica

O Eaf.Middleware.Web.Core é o módulo web do Enterprise Application Foundation (EAF). Este módulo fornece componentes web para ASP.NET Core incluindo configuração de startup, middleware, filtros, controllers, SignalR, Swagger, health checks e integração HTTP.

Este módulo serve como a camada de apresentação web, integrando todos os componentes do EAF com ASP.NET Core e fornecendo funcionalidades prontas para uso em aplicações web.

Relação com o EAF e ASP.NET Boilerplate

Integração com ABP

• Abp.AspNetCore: Framework base para ASP.NET Core
• Abp.AspNetCore.SignalR: Integração com SignalR para comunicação em tempo real
• Abp.HangFire.AspNetCore: Processamento de jobs em background
• Abp.AspNetCore.PerRequestRedisCache: Cache por requisição com Redis
• Abp.Zero.Common: Funcionalidades comuns do ABP Zero

Dependências do EAF

• Eaf.Middleware.Application: Camada de aplicação
• Eaf.SqlServerCache: Cache distribuído com SQL Server

Dependências Externas

• Serilog.Sinks.Elasticsearch: Exportação de logs para Elasticsearch
• Serilog.Sinks.Seq: Exportação de logs para Seq
• Swashbuckle.AspNetCore: Documentação de API com Swagger/OpenAPI
• Hangfire.SqlServer: Storage do Hangfire com SQL Server
• Hangfire.AspNetCore: Integração do Hangfire com ASP.NET Core
• Microsoft.Extensions.Caching.StackExchangeRedis: Cache com Redis

Principais Componentes

Authentication

• Configuração de autenticação JWT Bearer
• Autenticação Microsoft Account
• Gerenciamento de tokens

Configuration

• Configuração de startup do ASP.NET Core
• Configuração de middleware
• Configuração de serviços

Controllers

• Controllers base para APIs REST
• Filtros de autorização
• Tratamento de erros

SignalR

• Hubs para comunicação em tempo real
• Integração com chat
• Notificações em tempo real

Swagger

• Configuração de documentação de API
• Integração com OpenAPI
• UI do Swagger

Health Checks

• Health checks para monitoramento
• Integração com ASP.NET Core Health Checks

Guia de Instalação

Pré-requisitos

• .NET 10.0 SDK ou superior
• ASP.NET Boilerplate 10.4.0
• Eaf.Middleware.Application 10.4.0

Instalação via NuGet

dotnet add package Eaf.Middleware.Web.Core --version 10.4.0

Instalação via Referência de Projeto

Adicione a referência ao seu arquivo .csproj:

<ProjectReference Include="..\Eaf.Middleware.Web.Core\Eaf.Middleware.Web.Core.csproj" />

Exemplo Básico de Uso

1. Registrando o Módulo

No Startup.cs ou Program.cs:

[DependsOn(
    typeof(MiddlewareWebCoreModule),
    typeof(MiddlewareApplicationModule)
)]
public class MyWebModule : AbpModule
{
    public override void Initialize()
    {
        IocManager.RegisterAssemblyByConvention(Assembly.GetExecutingAssembly());
    }
}

2. Configurando o Startup

public class Startup
{
    public IConfiguration Configuration { get; }

    public Startup(IConfiguration configuration)
    {
        Configuration = configuration;
    }

    public void ConfigureServices(IServiceCollection services)
    {
        services.AddEafWebCore(options =>
        {
            options.ConnectionString = Configuration.GetConnectionString("Default");
        });
    }

    public void Configure(IApplicationBuilder app)
    {
        app.UseEafWebCore();
    }
}

3. Criando um Controller

public class TaskController : EafControllerBase
{
    private readonly ITaskAppService _taskAppService;

    public TaskController(ITaskAppService taskAppService)
    {
        _taskAppService = taskAppService;
    }

    [HttpGet]
    public async Task<PagedResultDto<TaskDto>> GetAll(GetAllTasksInput input)
    {
        return await _taskAppService.GetAll(input);
    }

    [HttpPost]
    public async Task<TaskDto> Create(CreateTaskInput input)
    {
        return await _taskAppService.Create(input);
    }

    [HttpPut]
    public async Task<TaskDto> Update(UpdateTaskInput input)
    {
        return await _taskAppService.Update(input);
    }

    [HttpDelete]
    public async Task Delete(EntityDto input)
    {
        await _taskAppService.Delete(input);
    }
}

4. Configurando Swagger

No Startup.cs:

public void ConfigureServices(IServiceCollection services)
{
    services.AddSwaggerGen(options =>
    {
        options.SwaggerDoc("v1", new OpenApiInfo
        {
            Title = "My API",
            Version = "v1",
            Description = "API documentation"
        });
    });
}

public void Configure(IApplicationBuilder app)
{
    app.UseSwagger();
    app.UseSwaggerUI(options =>
    {
        options.SwaggerEndpoint("/swagger/v1/swagger.json", "My API V1");
    });
}

5. Configurando SignalR

public class MyHub : AbpHub
{
    public async Task SendMessage(string message)
    {
        await Clients.All.SendAsync("ReceiveMessage", message);
    }
}

// No Startup.cs
public void Configure(IApplicationBuilder app)
{
    app.UseSignalR(routes =>
    {
        routes.MapHub<MyHub>("/myHub");
    });
}

6. Configurando Health Checks

public void ConfigureServices(IServiceCollection services)
{
    services.AddHealthChecks()
        .AddCheck("database", new SqlConnectionHealthCheck(Configuration.GetConnectionString("Default")))
        .AddCheck("redis", new RedisHealthCheck(Configuration.GetConnectionString("Redis")));
}

public void Configure(IApplicationBuilder app)
{
    app.UseHealthChecks("/health");
    app.UseHealthChecks("/health/ready", new HealthCheckOptions
    {
        Predicate = check => check.Name == "database"
    });
}

Estrutura do Módulo

Eaf.Middleware.Web.Core/
├── Authentication/         # Configurações de autenticação
├── Configuration/          # Configuração de startup e middleware
├── Controllers/            # Controllers base
├── Features/               # Features específicas
├── HealthChecks/           # Health checks
├── Helpers/                # Helpers utilitários
├── Models/                 # Models DTOs
├── Notifications/          # Notificações
├── Security/               # Configurações de segurança
├── Serilog/                # Configuração do Serilog
├── Session/                # Gerenciamento de sessão
├── SignalR/                # Hubs SignalR
├── Swagger/                # Configuração Swagger
├── UiCustomization/        # Customização de UI
├── Url/                    # Helpers de URL
└── WebHooks/               # WebHooks

Configurações Opcionais

Configuração de Serilog

public void ConfigureServices(IServiceCollection services)
{
    services.AddSerilog(options =>
    {
        options.WriteTo.Elasticsearch(Configuration.GetConnectionString("Elasticsearch"));
        options.WriteTo.Seq(Configuration.GetConnectionString("Seq"));
    });
}

Configuração de Redis Cache

{
  "Redis": {
    "ConnectionString": "localhost:6379",
    "InstanceName": "MyApp"
  }
}

Configuração de Hangfire

O Hangfire seleciona automaticamente o tipo de armazenamento com base no provider de banco de dados e configurações de Redis:

• SQL Server (Database:Provider = SqlServer/MSSQL): Usa SQL Server storage
• Não SQL Server + Redis habilitado (RedisCache:IsEnabled = true): Usa Redis storage via Hangfire.Redis.StackExchange
• Não SQL Server + Redis desabilitado: Usa armazenamento em memória

// A configuração é feita automaticamente pelo HangFireConfigurer.Configure()
// O tipo de storage é resolvido por HangFireConfigurer.ResolveStorageType()
public void ConfigureServices(IServiceCollection services)
{
    HangFireConfigurer.Configure(services, Configuration);
}

{
  "Hangfire": {
    "IsEnabled": "true",
    "IsInMemoryDatabase": "false"
  },
  "RedisCache": {
    "IsEnabled": "true",
    "ConnectionString": "localhost:6379",
    "DatabaseId": 0
  }
}

Testes

Os testes para este módulo devem ser criados seguindo o padrão dos outros módulos do EAF.

Licença

Este projeto faz parte do Enterprise Application Foundation (EAF) e está licenciado sob os mesmos termos do projeto principal.

Suporte

Para issues e perguntas, consulte o repositório principal do EAF: https://github.com/afonsoft/EAF