IW4M-Admin/WebfrontCore/Startup.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using System.Reflection;
using System.Threading.RateLimiting;
using System.Threading.Tasks;
using Data.Abstractions;
using Data.Helpers;
using FluentValidation;
using FluentValidation.AspNetCore;
using IW4MAdmin.Plugins.Stats.Dtos;
using IW4MAdmin.Plugins.Stats.Helpers;
using IW4MAdmin.WebfrontCore.Controllers.API.Validation;
using IW4MAdmin.WebfrontCore.Middleware;
using IW4MAdmin.WebfrontCore.QueryHelpers;
using IW4MAdmin.WebfrontCore.QueryHelpers.Models;
using Microsoft.AspNetCore.Authentication.Cookies;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Mvc.Razor;
using Microsoft.AspNetCore.RateLimiting;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using SharedLibraryCore;
using SharedLibraryCore.Configuration;
using SharedLibraryCore.Dtos;
using SharedLibraryCore.Dtos.Meta.Responses;
using SharedLibraryCore.Interfaces;
using SharedLibraryCore.Services;

namespace IW4MAdmin.WebfrontCore
{
    public class Startup
    {
        // This method gets called by the runtime. Use this method to add services to the container.
        public void ConfigureServices(IServiceCollection services)
        {
            // allow CORS
            services.AddCors(options =>
            {
                options.AddPolicy("AllowAll",
                    builder =>
                    {
                        builder.AllowAnyOrigin()
                            .AllowAnyMethod()
                            .AllowAnyHeader();
                    });
            });

            services.AddStackPolicy(options =>
            {
                options.MaxConcurrentRequests = int.Parse(Environment.GetEnvironmentVariable("MaxConcurrentRequests") ?? "1");
                options.RequestQueueLimit = int.Parse(Environment.GetEnvironmentVariable("RequestQueueLimit") ?? "1");
            });

            services.AddRateLimiter(options => options.AddConcurrencyLimiter("concurrencyPolicy", opt =>
            {
                opt.PermitLimit = 2;
                opt.QueueLimit = 25;
                opt.QueueProcessingOrder = QueueProcessingOrder.NewestFirst;
            }));

            // Add framework services.
            var mvcBuilder = services.AddMvc(options => options.SuppressAsyncSuffixInActionNames = false);
            services.AddFluentValidationAutoValidation().AddFluentValidationClientsideAdapters();

#if DEBUG
            {
                mvcBuilder = mvcBuilder.AddRazorRuntimeCompilation();
                services.Configure<RazorViewEngineOptions>(options =>
                {
                    options.ViewLocationFormats.Add(@"/Views/Plugins/{1}/{0}" + RazorViewEngine.ViewExtension);
                    options.ViewLocationFormats.Add("/Views/Plugins/Stats/Advanced.cshtml");
                });
            }
#endif

            foreach (var asm in PluginAssemblies())
            {
                mvcBuilder.AddApplicationPart(asm);
            }

            services.AddHttpContextAccessor();

            services.AddAuthentication(CookieAuthenticationDefaults.AuthenticationScheme)
                .AddCookie(CookieAuthenticationDefaults.AuthenticationScheme, options =>
                {
                    options.AccessDeniedPath = "/";
                    options.LoginPath = "/";
                    options.Events.OnValidatePrincipal += ClaimsPermissionRemoval.ValidateAsync;
                    options.Events.OnSignedIn += ClaimsPermissionRemoval.OnSignedIn;
                });

            services.AddSingleton<IResourceQueryHelper<ChatSearchQuery, MessageResponse>, ChatResourceQueryHelper>();
            services.AddTransient<IValidator<FindClientRequest>, FindClientRequestValidator>();
            services.AddSingleton<IResourceQueryHelper<FindClientRequest, FindClientResult>, ClientService>();
            services.AddSingleton<IResourceQueryHelper<StatsInfoRequest, StatsInfoResult>, StatsResourceQueryHelper>();
            services.AddSingleton<IResourceQueryHelper<StatsInfoRequest, AdvancedStatsInfo>, AdvancedClientStatsResourceQueryHelper>();
            services.AddSingleton(typeof(IDataValueCache<,>), typeof(DataValueCache<,>));
            services.AddSingleton<IResourceQueryHelper<BanInfoRequest, BanInfo>, BanInfoResourceQueryHelper>();
            return;

            IEnumerable<Assembly> PluginAssemblies()
            {
                var pluginDir = $"{Utilities.OperatingDirectory}Plugins{Path.DirectorySeparatorChar}";

                if (!Directory.Exists(pluginDir)) return [];

                var dllFileNames =
                    Directory.GetFiles($"{Utilities.OperatingDirectory}Plugins{Path.DirectorySeparatorChar}",
                        "*.dll");
                return dllFileNames.Select(Assembly.LoadFrom);
            }
        }

        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
        public void Configure(IApplicationBuilder app, IWebHostEnvironment env, IServiceProvider serviceProvider)
        {
            app.UseStatusCodePages(context =>
            {
                if (context.HttpContext.Response.StatusCode == (int)HttpStatusCode.NotFound)
                {
                    context.HttpContext.Response.Redirect($"/Home/ResponseStatusCode?statusCode={context.HttpContext.Response.StatusCode}");
                }

                return Task.CompletedTask;
            });

            if (env.EnvironmentName == "Development")
            {
                app.UseDeveloperExceptionPage();
            }
            else
            {
                app.UseExceptionHandler("/Home/Error");
            }

            if (Program.Manager.GetApplicationSettings().Configuration().EnableWebfrontConnectionWhitelist)
            {
                app.UseMiddleware<IPWhitelist>(serviceProvider.GetService<ILogger<IPWhitelist>>(),
                    serviceProvider.GetRequiredService<ApplicationConfiguration>().WebfrontConnectionWhitelist);
            }

            app.UseRateLimiter(new RateLimiterOptions()
                .AddConcurrencyLimiter("concurrencyPolicy", (options) =>
                {
                    options.PermitLimit = 2;
                    options.QueueLimit = 25;
                    options.QueueProcessingOrder = QueueProcessingOrder.NewestFirst;
                }));

            app.UseStaticFiles();
            app.UseAuthentication();
            app.UseCors("AllowAll");

            // prevents banned/demoted users from keeping their claims
            app.UseMiddleware<ClaimsPermissionRemoval>(Program.Manager);

            app.UseRouting();
            app.UseAuthorization();
            app.UseRateLimiter();
            app.UseEndpoints(endpoints =>
            {
                endpoints.MapControllerRoute("default", "{controller=Home}/{action=Index}/{id?}")
                    .RequireRateLimiting("concurrencyPolicy");
            });
        }
    }
}