Program.cs

using Microsoft.Extensions.FileProviders;
using SlowDown.Hubs;
using SlowDown.Services;
using Azure.Storage.Blobs;
using Microsoft.AspNetCore.Http.Connections;
using Microsoft.AspNetCore.Localization;
using System.Globalization;
using Azure.Security.KeyVault.Secrets;
using Azure.Identity;
using Microsoft.AspNetCore.Identity;
using Microsoft.AspNetCore.Authentication.Cookies;


namespace SlowDown
{
    public class Program
    {
        public static void Main(string[] args)
        {
            var builder = WebApplication.CreateBuilder(args);
            builder.WebHost.UseWebRoot("wwwroot");

                      
            builder.Services.AddControllers();
            builder.Services.AddSignalR();
            builder.Services.AddSession(options =>
            {
                options.IdleTimeout = TimeSpan.FromHours(4);
                options.Cookie.HttpOnly = true;
                options.Cookie.IsEssential = true;
                options.Cookie.SameSite = SameSiteMode.Lax;
                options.Cookie.SecurePolicy = CookieSecurePolicy.Always;
                
            });

            
            builder.Services.AddAuthentication("AdminCookie")
                .AddCookie("AdminCookie", options =>
                {
                    options.LoginPath = "/Opettajalogin";
                    options.AccessDeniedPath = "/Opettajalogin";
                    options.Cookie.HttpOnly = true;
                    options.Cookie.SameSite = SameSiteMode.Strict;
                    options.Cookie.SecurePolicy = CookieSecurePolicy.Always;
                });

            builder.Services.AddAuthorization(options =>
            {
                options.AddPolicy("AdminOnly", policy =>
                    policy.RequireClaim("IsAdmin", "true"));
            });

            
            builder.Services.AddSingleton<SessionService>();
            builder.Services.AddHostedService<SessionCleanupService>();
            builder.Services.AddSingleton<SlowDownService>();           
            
            builder.Services.AddSingleton<IAdminPasswordStore, KeyVaultAdminPasswordStore>();

            builder.Services.AddSingleton<IAdminPasswordService, AdminPasswordService>();

        
            builder.Services.AddHttpClient();

            
            builder.Services.AddHttpClient("backend", (sp, client) =>
            {
                var cfg = sp.GetRequiredService<IConfiguration>();
                var baseUrl = cfg["AppBaseUrl"];

                if (string.IsNullOrWhiteSpace(baseUrl))
                    throw new InvalidOperationException("AppBaseUrl missing.");
                
                    
                client.BaseAddress = new Uri(baseUrl);
                
            });

            
            var blobConnectionString = builder.Configuration["Azure:BlobConnectionString"];
                                                     
            if (string.IsNullOrWhiteSpace(blobConnectionString))
                throw new InvalidOperationException("Azure:BlobConnectionString missing.");

            builder.Services.AddSingleton(new BlobServiceClient(blobConnectionString));

            var blobContainerName = builder.Configuration["Azure:BlobContainerName"];

            if (string.IsNullOrWhiteSpace(blobContainerName))
            throw new InvalidOperationException("Azure:BlobContainerName missing.");


            builder.Services.AddLocalization(options => options.ResourcesPath = "Resources");

            builder.Services
            .AddRazorPages()
            .AddViewLocalization()
            .AddDataAnnotationsLocalization();


            var app = builder.Build();

            
            var supportedCultures = new[]
            {
    new CultureInfo("fi"),
    new CultureInfo("sv"),
    new CultureInfo("en"),
    new CultureInfo("ru"),
    new CultureInfo("uk")
};

            var localizationOptions = new RequestLocalizationOptions
            {
                DefaultRequestCulture = new RequestCulture("fi"),
                SupportedCultures = supportedCultures,
                SupportedUICultures = supportedCultures
            };


            
            localizationOptions.RequestCultureProviders = new IRequestCultureProvider[]
            {
                new CookieRequestCultureProvider(),
                new QueryStringRequestCultureProvider(),
                new AcceptLanguageHeaderRequestCultureProvider()
            };

            
            app.Lifetime.ApplicationStarted.Register(async () =>
            {
                try
                {
                    var svc = app.Services.GetRequiredService<BlobServiceClient>();
                    var container = svc.GetBlobContainerClient(blobContainerName);
                    await container.CreateIfNotExistsAsync();
                    Console.WriteLine($"Blob Storage OK, container '{blobContainerName}' käytössä.");
                }
                catch (Exception ex)
                {
                    Console.WriteLine($"Blob Storage virhe: {ex.Message}");
                }
            });
    
            app.UseHttpsRedirection();
        
            var webRoot = Path.Combine(app.Environment.ContentRootPath, "wwwroot");
            app.UseStaticFiles(new StaticFileOptions
            {
                FileProvider = new PhysicalFileProvider(webRoot),
                RequestPath = ""
            });

            app.UseRequestLocalization(localizationOptions);

            app.UseRouting();
            app.UseAuthentication();
            app.UseAuthorization();
            app.UseSession();

            app.MapRazorPages();
            app.MapControllers();
            app.MapHub<ClassHub>("/hub", options =>
            {
                options.Transports = HttpTransportType.LongPolling;
            });

            app.Run();
        }
    }
}