poprhythm
5fdd5fadba
This commit updates the LocationParsingConfiguration to include additional location patterns such as "Exhibit Hall *", "Mtg. Room *", and "Online". The EventOccurrenceParser has been enhanced to better handle parsing issues, including skipping comment and continuation lines, and cleaning up location text. New methods for analyzing location parsing failures and categorizing issues have been added to improve reporting. Additionally, the UI has been updated to support larger input sizes for event occurrence text, ensuring a smoother user experience during data import.
340 lines
12 KiB
C#
340 lines
12 KiB
C#
using Data;
|
|
using Microsoft.AspNetCore.DataProtection;
|
|
using Microsoft.AspNetCore.SignalR;
|
|
using Microsoft.AspNetCore.StaticFiles;
|
|
using Microsoft.EntityFrameworkCore;
|
|
using MudBlazor.Services;
|
|
using Serilog;
|
|
using System.Text.Json;
|
|
using VisNetwork.Blazor;
|
|
using WebApp;
|
|
using WebApp.Authentication;
|
|
using WebApp.Components;
|
|
using WebApp.Logging;
|
|
|
|
var builder = WebApplication.CreateBuilder(args);
|
|
|
|
// Load appsettings from Data directory (works in both development and production)
|
|
// This allows runtime configuration changes without touching the codebase
|
|
var dataAppSettingsPath = Path.Combine(builder.Environment.ContentRootPath, "Data", "appsettings.json");
|
|
if (!File.Exists(dataAppSettingsPath))
|
|
{
|
|
Console.WriteLine($"appsettings.json not found at {dataAppSettingsPath}. Creating from template...");
|
|
|
|
try
|
|
{
|
|
// Ensure Data directory exists
|
|
Directory.CreateDirectory(Path.Combine(builder.Environment.ContentRootPath, "Data"));
|
|
|
|
// Copy ChapterSettings and ValidationSettings from the base appsettings.json
|
|
var baseAppSettingsPath = Path.Combine(builder.Environment.ContentRootPath, "appsettings.json");
|
|
if (File.Exists(baseAppSettingsPath))
|
|
{
|
|
var baseConfig = File.ReadAllText(baseAppSettingsPath);
|
|
var baseDoc = JsonDocument.Parse(baseConfig);
|
|
|
|
var templateSettings = new Dictionary<string, object?>();
|
|
|
|
if (baseDoc.RootElement.TryGetProperty("ChapterSettings", out var chapterSettings))
|
|
{
|
|
templateSettings["ChapterSettings"] = JsonSerializer.Deserialize<object>(chapterSettings.GetRawText());
|
|
}
|
|
|
|
if (baseDoc.RootElement.TryGetProperty("ValidationSettings", out var validationSettings))
|
|
{
|
|
templateSettings["ValidationSettings"] = JsonSerializer.Deserialize<object>(validationSettings.GetRawText());
|
|
}
|
|
|
|
if (baseDoc.RootElement.TryGetProperty("LocationParsingSettings", out var locationParsingSettings))
|
|
{
|
|
templateSettings["LocationParsingSettings"] = JsonSerializer.Deserialize<object>(locationParsingSettings.GetRawText());
|
|
}
|
|
|
|
if (templateSettings.Any())
|
|
{
|
|
var json = JsonSerializer.Serialize(templateSettings, new JsonSerializerOptions
|
|
{
|
|
WriteIndented = true
|
|
});
|
|
|
|
File.WriteAllText(dataAppSettingsPath, json);
|
|
Console.WriteLine("appsettings.json created in Data directory.");
|
|
}
|
|
else
|
|
{
|
|
Console.WriteLine("WARNING: No settings to copy from base appsettings.json");
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine($"WARNING: Unable to create appsettings.json: {ex.Message}");
|
|
}
|
|
}
|
|
|
|
// Add Data/appsettings.json as additional configuration source (all environments)
|
|
if (File.Exists(dataAppSettingsPath))
|
|
{
|
|
builder.Configuration.AddJsonFile(dataAppSettingsPath, optional: true, reloadOnChange: true);
|
|
Console.WriteLine($"Loaded configuration from {dataAppSettingsPath}");
|
|
}
|
|
|
|
// Configure Serilog with custom handling for antiforgery errors
|
|
builder.Host.UseSerilog((context, configuration) =>
|
|
{
|
|
var consoleOutputTemplate = "[{Timestamp:HH:mm:ss} {Level:u3}] {Message:lj} {Properties:j}{NewLine}{Exception}";
|
|
var fileOutputTemplate = "{Timestamp:yyyy-MM-dd HH:mm:ss.fff zzz} [{Level:u3}] {Message:lj} {Properties:j}{NewLine}{Exception}";
|
|
|
|
// Create console logger with antiforgery error handling
|
|
var consoleConfig = new LoggerConfiguration()
|
|
.WriteTo.Console(outputTemplate: consoleOutputTemplate);
|
|
var consoleLogger = consoleConfig.CreateLogger();
|
|
|
|
// Create file logger with antiforgery error handling
|
|
var fileConfig = new LoggerConfiguration()
|
|
.WriteTo.File(
|
|
path: "logs/webapp-.txt",
|
|
rollingInterval: RollingInterval.Day,
|
|
retainedFileCountLimit: 30,
|
|
outputTemplate: fileOutputTemplate);
|
|
var fileLogger = fileConfig.CreateLogger();
|
|
|
|
configuration
|
|
.ReadFrom.Configuration(context.Configuration)
|
|
.Enrich.FromLogContext()
|
|
.WriteTo.Sink(new AntiforgeryLogEventSink(consoleLogger))
|
|
.WriteTo.Sink(new AntiforgeryLogEventSink(fileLogger));
|
|
});
|
|
|
|
// Configure authentication secrets for production (Docker, etc.)
|
|
if (builder.Environment.IsProduction())
|
|
{
|
|
// Option 1: Load from volume-mounted secrets file in Data directory
|
|
var secretsPath = Path.Combine(builder.Environment.ContentRootPath, "Data", "auth-secrets.json");
|
|
if (File.Exists(secretsPath))
|
|
{
|
|
builder.Configuration.AddJsonFile(secretsPath, optional: false, reloadOnChange: true);
|
|
}
|
|
|
|
// Option 2: Environment variables with prefix
|
|
builder.Configuration.AddEnvironmentVariables(prefix: "TSA_");
|
|
}
|
|
|
|
// Add services to the container.
|
|
builder.Services.AddControllersWithViews();
|
|
// Configure SignalR HubOptions to support large text inputs (e.g., pasted event occurrence files)
|
|
// Default limit is around 32KB, increase to 1MB to support large pasted text files
|
|
builder.Services.AddRazorComponents()
|
|
.AddInteractiveServerComponents()
|
|
.AddHubOptions(options =>
|
|
{
|
|
// Increase maximum message size to 1MB to support large pasted text files
|
|
// The test file is ~430 lines, which is well within this limit
|
|
options.MaximumReceiveMessageSize = 1024 * 1024; // 1MB
|
|
});
|
|
|
|
builder.Services.AddMudServices();
|
|
builder.Services.AddVisNetwork();
|
|
|
|
// Configure Data Protection to persist keys across container restarts
|
|
var keysPath = Path.Combine(builder.Environment.ContentRootPath, "DataProtectionKeys");
|
|
|
|
// Try to create the directory if it doesn't exist
|
|
try
|
|
{
|
|
if (!Directory.Exists(keysPath))
|
|
{
|
|
Directory.CreateDirectory(keysPath);
|
|
Console.WriteLine($"Created DataProtectionKeys directory at: {keysPath}");
|
|
}
|
|
}
|
|
catch (UnauthorizedAccessException ex)
|
|
{
|
|
Console.WriteLine($"WARNING: Unable to create DataProtectionKeys directory at {keysPath}");
|
|
Console.WriteLine($"Error: {ex.Message}");
|
|
Console.WriteLine("This may cause issues with antiforgery tokens and authentication cookies.");
|
|
Console.WriteLine("Ensure the volume mount has correct permissions for the container user.");
|
|
}
|
|
|
|
builder.Services.AddDataProtection()
|
|
.PersistKeysToFileSystem(new DirectoryInfo(keysPath))
|
|
.SetApplicationName("TSA-Chapter-Organizer");
|
|
|
|
// Ensure Data directory exists
|
|
var dataPath = Path.Combine(builder.Environment.ContentRootPath, "Data");
|
|
try
|
|
{
|
|
if (!Directory.Exists(dataPath))
|
|
{
|
|
Directory.CreateDirectory(dataPath);
|
|
Console.WriteLine($"Created Data directory at: {dataPath}");
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine($"WARNING: Unable to create Data directory at {dataPath}: {ex.Message}");
|
|
}
|
|
|
|
// Configure SQLite with hardcoded connection string
|
|
var connectionString = "Data Source=Data/app.db";
|
|
builder.Services.AddDbContext<AppDbContext>(options =>
|
|
{
|
|
options.UseSqlite(connectionString,
|
|
sqliteOptions => sqliteOptions.UseQuerySplittingBehavior(QuerySplittingBehavior.SplitQuery));
|
|
});
|
|
|
|
builder.Services.AddQuickGridEntityFrameworkAdapter();
|
|
|
|
builder.Services.AddDatabaseDeveloperPageExceptionFilter();
|
|
|
|
builder.Services.AddScoped<ClipboardService>();
|
|
builder.Services.AddScoped<WebApp.LocalStorageService>();
|
|
builder.Services.AddScoped<WebApp.Services.IEventOccurrenceService, WebApp.Services.EventOccurrenceService>();
|
|
// EventOccurrenceParserService with configuration injection
|
|
builder.Services.AddScoped<Core.Services.IEventOccurrenceParserService>(sp =>
|
|
{
|
|
var configuration = sp.GetRequiredService<IConfiguration>();
|
|
return new Core.Services.EventOccurrenceParserService(configuration);
|
|
});
|
|
builder.Services.AddScoped<WebApp.Services.FormValidationService>();
|
|
builder.Services.AddScoped<WebApp.Services.EventDefinitionService>();
|
|
|
|
// State container for maintaining state per user connection (Blazor Server)
|
|
builder.Services.AddScoped<StateContainer>();
|
|
|
|
// Load validation configuration from appsettings (or use default if not found)
|
|
var validationConfig = builder.Configuration
|
|
.GetSection("ValidationSettings")
|
|
.Get<Core.Validation.ValidationConfiguration>() ?? Core.Validation.ValidationConfiguration.Default;
|
|
|
|
// Validation service with loaded configuration
|
|
builder.Services.AddScoped<Core.Validation.ValidationService>(sp =>
|
|
new Core.Validation.ValidationService(validationConfig));
|
|
|
|
// Add authentication services
|
|
builder.Services.AddHttpContextAccessor();
|
|
builder.Services.AddScoped<AuthenticationService>();
|
|
builder.Services.AddSingleton<LoginRateLimitService>();
|
|
builder.Services.AddHostedService<LoginRateLimitService>(sp => sp.GetRequiredService<LoginRateLimitService>());
|
|
|
|
// Add authentication options
|
|
builder.Services.AddAuthentication("Auth")
|
|
.AddCookie("Auth", options =>
|
|
{
|
|
options.ExpireTimeSpan = TimeSpan.FromMinutes(20);
|
|
options.SlidingExpiration = true;
|
|
options.LoginPath = "/login";
|
|
|
|
// Enhanced security settings
|
|
options.Cookie.HttpOnly = true;
|
|
options.Cookie.SecurePolicy = builder.Environment.IsDevelopment()
|
|
? CookieSecurePolicy.SameAsRequest
|
|
: CookieSecurePolicy.Always;
|
|
options.Cookie.SameSite = SameSiteMode.Strict;
|
|
options.Cookie.Name = "TSA.Auth";
|
|
});
|
|
builder.Services.AddCascadingAuthenticationState();
|
|
|
|
var app = builder.Build();
|
|
|
|
// Check and apply database migrations
|
|
using (var scope = app.Services.CreateScope())
|
|
{
|
|
var services = scope.ServiceProvider;
|
|
var logger = services.GetRequiredService<ILogger<Program>>();
|
|
|
|
try
|
|
{
|
|
var context = services.GetRequiredService<AppDbContext>();
|
|
|
|
// Check for pending migrations
|
|
var pendingMigrations = await context.Database.GetPendingMigrationsAsync();
|
|
|
|
if (pendingMigrations.Any())
|
|
{
|
|
logger.LogInformation(
|
|
"Applying database migrations: {Migrations}",
|
|
string.Join(", ", pendingMigrations));
|
|
await context.Database.MigrateAsync();
|
|
logger.LogInformation("Database migrations applied successfully");
|
|
}
|
|
else
|
|
{
|
|
logger.LogInformation("Database is up to date");
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
logger.LogError(ex, "An error occurred while checking database migrations");
|
|
throw;
|
|
}
|
|
}
|
|
|
|
// Configure the HTTP request pipeline.
|
|
if (!app.Environment.IsDevelopment())
|
|
{
|
|
app.UseExceptionHandler("/Error", createScopeForErrors: true);
|
|
// The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
|
|
app.UseHsts();
|
|
app.UseMigrationsEndPoint();
|
|
}
|
|
else
|
|
{
|
|
// Only redirect to HTTPS in development (production should use reverse proxy)
|
|
app.UseHttpsRedirection();
|
|
}
|
|
app.UseRouting();
|
|
|
|
app.UseAuthentication();
|
|
app.UseAuthorization();
|
|
|
|
// Configure static files with proper cache headers for Blazor assets
|
|
app.UseStaticFiles(new StaticFileOptions
|
|
{
|
|
OnPrepareResponse = ctx =>
|
|
{
|
|
// Blazor framework files: Use ETags with short cache and revalidation
|
|
// This allows caching for performance but ensures fresh files after deployments
|
|
// Browser will check ETag on each request (304 Not Modified if unchanged)
|
|
if (ctx.File.Name.Contains("_framework") ||
|
|
ctx.File.Name.Contains("blazor") ||
|
|
ctx.File.Name.EndsWith(".dll") ||
|
|
ctx.File.Name.EndsWith(".wasm"))
|
|
{
|
|
// Cache for 12 hours, but must revalidate (check ETag) before using
|
|
// If file hasn't changed, browser gets 304 Not Modified (no download)
|
|
// If file changed, browser downloads new version
|
|
ctx.Context.Response.Headers.Append("Cache-Control", "public, max-age=43200, must-revalidate");
|
|
}
|
|
else
|
|
{
|
|
// Other static files (CSS, images, etc.) can be cached long-term
|
|
ctx.Context.Response.Headers.Append("Cache-Control", "public, max-age=31536000");
|
|
}
|
|
}
|
|
});
|
|
app.UseAntiforgery();
|
|
|
|
app.MapRazorComponents<App>()
|
|
.AddInteractiveServerRenderMode();
|
|
|
|
// Used for AuthController
|
|
app.MapControllerRoute("default", "{controller}/{action}");
|
|
|
|
// Development-only password hash generator endpoint
|
|
if (app.Environment.IsDevelopment())
|
|
{
|
|
app.MapGet("/dev/hash-password", (string password) =>
|
|
{
|
|
var hash = PasswordHashGenerator.GenerateHash(password);
|
|
return Results.Ok(new
|
|
{
|
|
password,
|
|
hash,
|
|
message = "Copy the hash value to your User Secrets configuration"
|
|
});
|
|
}).WithName("GeneratePasswordHash");
|
|
}
|
|
|
|
app.Run();
|