TaskAPI/Program.cs - master - ilyamikhaylov07/integration_solution_course

TaskAPI/Program.cs
186 строк6 KB
Ilya
add 4 laba
02 ноя 2025, 19:16
02 ноя 2025, 19:16fdd8d01
using Microsoft.AspNetCore.Authentication.JwtBearer;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.ApiExplorer;
using Microsoft.AspNetCore.Mvc.Versioning;
using Microsoft.EntityFrameworkCore;
using Microsoft.IdentityModel.Tokens;
using RabbitMQ.Client;
using System.Security.Claims;
using System.Threading.RateLimiting;
using TaskAPI.Database;
using TaskAPI.Messaging;
using TaskAPI.Middleware;
using TaskAPI.Services;
using TaskAPI.Settings;

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.

builder.Services.AddControllers();
// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
builder.Services.AddEndpointsApiExplorer();

builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
    .AddJwtBearer("Access", options =>
    {
        options.TokenValidationParameters = new TokenValidationParameters
        {
            ClockSkew = TimeSpan.FromMinutes(1),
            ValidateIssuer = true,
            ValidIssuer = AuthOptions.ISSUER,
            ValidateAudience = true,
            ValidAudience = AuthOptions.AUDIENCE,
            ValidateLifetime = true,
            IssuerSigningKey = AuthOptions.GetSymSecurityKey(),
            ValidateIssuerSigningKey = true,
        };
        options.Events = new JwtBearerEvents
        {
            OnAuthenticationFailed = context =>
            {
                return Task.CompletedTask;
            },
            OnTokenValidated = context =>
            {
                return Task.CompletedTask;
            }
        };
    })
    .AddJwtBearer("Refresh", options =>
    {
        options.TokenValidationParameters = new TokenValidationParameters
        {
            ClockSkew = TimeSpan.FromMinutes(1),
            ValidateIssuer = false,
            ValidateAudience = false,
            ValidateLifetime = true,
            IssuerSigningKey = AuthOptions.GetSymSecurityKey(),
            ValidateIssuerSigningKey = true,
        };

    });

builder.Services.AddAuthorization();

builder.Services.Configure<RateLimitedOptions>(
    builder.Configuration.GetSection(RateLimitedOptions.MyRateLimit));

var optionsLimited = new RateLimitedOptions();

builder.Configuration.GetSection(RateLimitedOptions.MyRateLimit).Bind(optionsLimited);
string slidingPolicy = "sliding";

builder.Services.AddRateLimiter(opt =>
{
    opt.OnRejected = async (context, token) =>
    {
        context.HttpContext.Response.Headers["Retry-After"] = "60";
        context.HttpContext.Response.Headers["X-Limit-Remaining"] = "0";
    };
    opt.RejectionStatusCode = 429;
    opt.AddPolicy(slidingPolicy, context =>
    {
        var email = context.User?.Claims.FirstOrDefault(c => c.Type == ClaimTypes.Email)?.Value
                    ?? "anonymous";

        return RateLimitPartition.GetSlidingWindowLimiter(email, _ =>
            new SlidingWindowRateLimiterOptions
            {
                PermitLimit = optionsLimited.SlidingPermitLimit,
                Window = TimeSpan.FromSeconds(optionsLimited.Window),
                SegmentsPerWindow = optionsLimited.SegmentsPerWindow,
                QueueProcessingOrder = QueueProcessingOrder.OldestFirst,
                QueueLimit = optionsLimited.QueueLimit
            });
    });
});

builder.Services.AddApiVersioning(options =>
{
    options.ReportApiVersions = true;
    options.AssumeDefaultVersionWhenUnspecified = true;
    options.DefaultApiVersion = new ApiVersion(1, 0);

    options.ApiVersionReader = new QueryStringApiVersionReader("api-version");
});
builder.Services.AddVersionedApiExplorer(options =>
{
    options.GroupNameFormat = "'v'VVV"; // Форматы v1, v2
    options.SubstituteApiVersionInUrl = false; // Подставлять версию в маршрут
});

builder.Services.AddSwaggerDocumentation();

builder.Services.AddCors(options =>
{
    options.AddPolicy(name: "AllowAll", policy =>
        policy
            .AllowAnyOrigin()
            .AllowAnyMethod()
            .AllowAnyHeader());
});

string connStr = builder.Configuration.GetConnectionString("DefaultConnection")!;

builder.Services.AddDbContext<TaskDbContext>(options =>
{
    options.UseNpgsql(connStr);
});

builder.Services.AddScoped<UsersService>();
builder.Services.AddScoped<TasksService>();
builder.Services.AddScoped<ProjectsService>();
builder.Services.AddScoped<AuthService>();

var factory = new ConnectionFactory { HostName = "localhost", Port = 5672 };
var rabbitConnection = await factory.CreateConnectionAsync();
builder.Services.AddSingleton<IConnection>(rabbitConnection);

builder.Services.AddScoped<TaskApiServer>();
builder.Services.AddSingleton<RabbitMqService>();
builder.Services.AddHostedService<RabbitMqBackgroundService>();

builder.Services.AddScoped(provider =>
{
    return new TokenManager(
        AuthOptions.GetSymSecurityKey(),
        AuthOptions.ISSUER,
        AuthOptions.AUDIENCE
        );
});

builder.Services.AddMemoryCache();


var app = builder.Build();

// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment())
{
    var provider = app.Services.GetRequiredService<IApiVersionDescriptionProvider>();
    app.UseSwagger();
    app.UseSwaggerUI(c =>
    {
        foreach (var description in provider.ApiVersionDescriptions)
        {
            c.SwaggerEndpoint($"/swagger/{description.GroupName}/swagger.json",
                              $"TaskAPI {description.GroupName}");
        }
    });
}


app.UseRateLimiter();

app.UseMiddleware<IdempotencyMiddleware>();

app.UseHttpsRedirection();

app.UseCors("AllowAll");

app.UseAuthorization();

app.MapControllers().RequireRateLimiting(slidingPolicy);

app.Run();