812 lines
31 KiB
C#
812 lines
31 KiB
C#
using NexusReader.Web.Components;
|
||
using Microsoft.AspNetCore.Mvc;
|
||
using Microsoft.AspNetCore.Components;
|
||
using NexusReader.Application;
|
||
using NexusReader.Infrastructure;
|
||
using NexusReader.Application.Abstractions.Services;
|
||
using NexusReader.Application.Queries.User;
|
||
using NexusReader.Application.Commands.Library;
|
||
using NexusReader.Application.Queries.Library;
|
||
using NexusReader.Application.Queries.Concepts;
|
||
using MediatR;
|
||
using NexusReader.Web.Client.Services;
|
||
using NexusReader.UI.Shared.Services;
|
||
using NexusReader.Domain.Entities;
|
||
using NexusReader.Data.Persistence;
|
||
using Microsoft.AspNetCore.Identity;
|
||
using Microsoft.AspNetCore.Components.Authorization;
|
||
using Microsoft.EntityFrameworkCore;
|
||
using Microsoft.AspNetCore.Authorization;
|
||
using NexusReader.Infrastructure.Identity;
|
||
using Microsoft.AspNetCore.Authentication;
|
||
using System.Security.Claims;
|
||
using NexusReader.Infrastructure.Services;
|
||
using Stripe;
|
||
using Microsoft.Extensions.AI;
|
||
using NexusReader.Application.Abstractions.Persistence;
|
||
using NexusReader.Application.Abstractions.Messaging;
|
||
using Hangfire;
|
||
|
||
AppContext.SetSwitch("Npgsql.EnableLegacyTimestampBehavior", true);
|
||
|
||
var builder = WebApplication.CreateBuilder(args);
|
||
|
||
// Add services to the container.
|
||
builder.Services.AddRazorComponents()
|
||
.AddInteractiveServerComponents()
|
||
.AddInteractiveWebAssemblyComponents();
|
||
|
||
builder.Services.ConfigureHttpJsonOptions(options =>
|
||
{
|
||
options.SerializerOptions.TypeInfoResolverChain.Insert(0, NexusReader.Application.Common.AppJsonContext.Default);
|
||
});
|
||
|
||
// Enable detailed circuit errors for Server‑Side Blazor components
|
||
builder.Services.AddServerSideBlazor()
|
||
.AddCircuitOptions(options =>
|
||
{
|
||
options.DetailedErrors = true;
|
||
});
|
||
builder.Services.AddSignalR();
|
||
builder.Services.AddHttpContextAccessor();
|
||
|
||
builder.Services.AddScoped<IPlatformService, WebPlatformService>();
|
||
builder.Services.AddScoped<INativeStorageService, NexusReader.Web.Services.NativeStorageService>();
|
||
builder.Services.AddScoped<IThemeService, ThemeService>();
|
||
// Feature settings (avoiding direct raw IConfiguration injection in client pages)
|
||
var featureSettings = builder.Configuration.GetSection("Features").Get<FeatureSettings>() ?? new FeatureSettings();
|
||
builder.Services.AddSingleton(featureSettings);
|
||
builder.Services.AddScoped<IQuizStateService, QuizStateService>();
|
||
builder.Services.AddScoped<IFocusModeService, FocusModeService>();
|
||
builder.Services.AddScoped<IReaderNavigationService, ReaderNavigationService>();
|
||
builder.Services.AddScoped<IKnowledgeGraphService, KnowledgeGraphService>();
|
||
builder.Services.AddScoped<IReaderInteractionService, ReaderInteractionService>();
|
||
builder.Services.AddScoped<IReaderStateService, ReaderStateService>();
|
||
builder.Services.AddScoped<ILibraryStateService, LibraryStateService>();
|
||
builder.Services.AddScoped<KnowledgeCoordinator>();
|
||
builder.Services.AddScoped<ISyncService, SyncService>();
|
||
|
||
builder.Services.AddHttpClient("NexusAPI", (sp, client) =>
|
||
{
|
||
var configuration = sp.GetRequiredService<IConfiguration>();
|
||
var apiBaseUrl = configuration["ApiBaseUrl"];
|
||
if (!string.IsNullOrEmpty(apiBaseUrl))
|
||
{
|
||
client.BaseAddress = new Uri(apiBaseUrl);
|
||
}
|
||
else
|
||
{
|
||
// For local development/Interactive Server, we use the current base address
|
||
var nav = sp.GetRequiredService<NavigationManager>();
|
||
client.BaseAddress = new Uri(nav.BaseUri);
|
||
}
|
||
});
|
||
builder.Services.AddScoped(sp => sp.GetRequiredService<IHttpClientFactory>().CreateClient("NexusAPI"));
|
||
|
||
builder.Services.AddScoped<IIdentityService, NexusReader.Web.Services.ServerIdentityService>();
|
||
builder.Services.AddScoped<IConceptsMapService, NexusReader.Web.Services.ServerConceptsMapService>();
|
||
builder.Services.AddCascadingAuthenticationState();
|
||
|
||
builder.Services.AddApplication();
|
||
builder.Services.AddInfrastructure(builder.Configuration);
|
||
|
||
builder.Services.AddMediatR(cfg => cfg.RegisterServicesFromAssemblies(
|
||
NexusReader.Application.DependencyInjection.Assembly,
|
||
NexusReader.Infrastructure.DependencyInjection.Assembly
|
||
));
|
||
|
||
// Authorization Policies
|
||
builder.Services.AddScoped<IAuthorizationHandler, TokenLimitHandler>();
|
||
builder.Services.AddAuthorizationBuilder()
|
||
.SetDefaultPolicy(new Microsoft.AspNetCore.Authorization.AuthorizationPolicyBuilder(
|
||
IdentityConstants.ApplicationScheme,
|
||
IdentityConstants.BearerScheme)
|
||
.RequireAuthenticatedUser()
|
||
.Build())
|
||
.AddPolicy("ProUser", policy => policy.RequireClaim("Plan", SubscriptionPlan.ProName, SubscriptionPlan.EnterpriseName))
|
||
.AddPolicy("HasAvailableTokens", policy => policy.AddRequirements(new TokenLimitRequirement()));
|
||
|
||
// Billing & Stripe
|
||
builder.Services.AddScoped<IBillingService, NexusReader.Infrastructure.Services.BillingService>();
|
||
|
||
// Authentication
|
||
builder.Services.AddAuthentication(options =>
|
||
{
|
||
options.DefaultScheme = IdentityConstants.ApplicationScheme;
|
||
options.DefaultSignInScheme = IdentityConstants.ExternalScheme;
|
||
})
|
||
.AddGoogle(options =>
|
||
{
|
||
options.ClientId = builder.Configuration["Authentication:Google:ClientId"] ?? "placeholder-id";
|
||
options.ClientSecret = builder.Configuration["Authentication:Google:ClientSecret"] ?? "placeholder-secret";
|
||
});
|
||
|
||
builder.Services.AddIdentityApiEndpoints<NexusUser>()
|
||
.AddRoles<IdentityRole>()
|
||
.AddEntityFrameworkStores<AppDbContext>()
|
||
.AddClaimsPrincipalFactory<NexusReader.Web.Services.CustomUserClaimsPrincipalFactory>();
|
||
|
||
builder.Services.ConfigureApplicationCookie(options =>
|
||
{
|
||
options.LoginPath = "/account/login";
|
||
options.LogoutPath = "/account/logout";
|
||
options.AccessDeniedPath = "/account/access-denied";
|
||
options.Cookie.Name = "NexusReader.Auth";
|
||
options.Cookie.HttpOnly = true;
|
||
options.Cookie.SameSite = SameSiteMode.Lax;
|
||
options.Cookie.SecurePolicy = CookieSecurePolicy.SameAsRequest;
|
||
options.ExpireTimeSpan = TimeSpan.FromDays(30);
|
||
options.SlidingExpiration = true;
|
||
|
||
options.Events.OnRedirectToLogin = context =>
|
||
{
|
||
var isApiRequest = context.Request.Path.StartsWithSegments("/api") ||
|
||
context.Request.Path.StartsWithSegments("/identity") ||
|
||
context.Request.Headers["Accept"].ToString().Contains("application/json");
|
||
|
||
if (isApiRequest)
|
||
{
|
||
context.Response.StatusCode = StatusCodes.Status401Unauthorized;
|
||
}
|
||
else
|
||
{
|
||
context.Response.Redirect(context.RedirectUri);
|
||
}
|
||
return Task.CompletedTask;
|
||
};
|
||
});
|
||
|
||
builder.Services.Configure<IdentityOptions>(options =>
|
||
{
|
||
// Password settings
|
||
options.Password.RequireDigit = true;
|
||
options.Password.RequireLowercase = true;
|
||
options.Password.RequireNonAlphanumeric = true;
|
||
options.Password.RequireUppercase = true;
|
||
options.Password.RequiredLength = 8;
|
||
options.Password.RequiredUniqueChars = 1;
|
||
|
||
// Lockout settings
|
||
options.Lockout.DefaultLockoutTimeSpan = TimeSpan.FromMinutes(5);
|
||
options.Lockout.MaxFailedAccessAttempts = 5;
|
||
options.Lockout.AllowedForNewUsers = true;
|
||
|
||
// User settings
|
||
options.User.AllowedUserNameCharacters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-._@+";
|
||
options.User.RequireUniqueEmail = true;
|
||
});
|
||
|
||
var app = builder.Build();
|
||
|
||
app.UseHangfireDashboard();
|
||
|
||
// Startup Validation
|
||
using (var scope = app.Services.CreateScope())
|
||
{
|
||
var marker = scope.ServiceProvider.GetService<IInfrastructureMarker>();
|
||
if (marker == null)
|
||
{
|
||
throw new InvalidOperationException("CRITICAL: Infrastructure layer was not registered. Ensure AddInfrastructure() is called in Program.cs.");
|
||
}
|
||
}
|
||
|
||
// Ensure Database is initialized and seeded
|
||
using (var scope = app.Services.CreateScope())
|
||
{
|
||
var services = scope.ServiceProvider;
|
||
var logger = services.GetRequiredService<ILogger<Program>>();
|
||
var dbContextFactory = services.GetRequiredService<IDbContextFactory<NexusReader.Data.Persistence.AppDbContext>>();
|
||
using var dbContext = await dbContextFactory.CreateDbContextAsync();
|
||
|
||
int maxRetries = 5;
|
||
int delayMs = 2000;
|
||
|
||
for (int i = 0; i < maxRetries; i++)
|
||
{
|
||
try
|
||
{
|
||
if (logger.IsEnabled(LogLevel.Information))
|
||
{
|
||
logger.LogInformation("Próba połączenia z bazą danych (próba {Attempt}/{MaxRetries})...", i + 1, maxRetries);
|
||
}
|
||
|
||
|
||
|
||
await DbInitializer.SeedAsync(services);
|
||
await TriggerBackgroundProcessingForUnindexedBooksAsync(services);
|
||
|
||
if (logger.IsEnabled(LogLevel.Information))
|
||
{
|
||
logger.LogInformation("Baza danych zainicjowana pomyślnie.");
|
||
}
|
||
break;
|
||
}
|
||
catch (Npgsql.NpgsqlException ex) when (i < maxRetries - 1)
|
||
{
|
||
if (logger.IsEnabled(LogLevel.Warning))
|
||
{
|
||
logger.LogWarning(ex, "Błąd połączenia z bazą danych. Ponowna próba za {Delay}ms...", delayMs);
|
||
}
|
||
|
||
await Task.Delay(delayMs);
|
||
delayMs *= 2; // Exponential backoff
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
if (logger.IsEnabled(LogLevel.Critical))
|
||
{
|
||
logger.LogCritical(ex, "Krytyczny błąd podczas inicjalizacji bazy danych.");
|
||
}
|
||
throw;
|
||
}
|
||
}
|
||
}
|
||
|
||
// Configure the HTTP request pipeline.
|
||
if (app.Environment.IsDevelopment())
|
||
{
|
||
app.UseWebAssemblyDebugging();
|
||
}
|
||
else
|
||
{
|
||
app.UseExceptionHandler("/Error", createScopeForErrors: true);
|
||
app.UseHsts();
|
||
}
|
||
|
||
app.UseStatusCodePagesWithReExecute("/not-found", createScopeForStatusCodePages: true);
|
||
if (!app.Environment.IsDevelopment())
|
||
{
|
||
app.UseHttpsRedirection();
|
||
}
|
||
|
||
app.UseRouting();
|
||
app.UseAuthentication();
|
||
app.UseAuthorization();
|
||
app.UseAntiforgery();
|
||
|
||
// Feature flags: block registration & password reset in restricted environments (e.g. Test)
|
||
var allowRegistration = app.Configuration.GetValue<bool?>("Features:AllowRegistration") ?? true;
|
||
var allowPasswordReset = app.Configuration.GetValue<bool?>("Features:AllowPasswordReset") ?? true;
|
||
|
||
if (!allowRegistration || !allowPasswordReset)
|
||
{
|
||
app.Use(async (context, next) =>
|
||
{
|
||
var path = context.Request.Path.Value?.ToLowerInvariant();
|
||
|
||
if (!allowRegistration && path is "/identity/register" or "/account/register")
|
||
{
|
||
context.Response.StatusCode = StatusCodes.Status403Forbidden;
|
||
await context.Response.WriteAsync("Registration is disabled in this environment.");
|
||
return;
|
||
}
|
||
|
||
if (!allowPasswordReset && path is "/identity/forgotpassword" or "/account/forgot-password")
|
||
{
|
||
context.Response.StatusCode = StatusCodes.Status403Forbidden;
|
||
await context.Response.WriteAsync("Password reset is disabled in this environment.");
|
||
return;
|
||
}
|
||
|
||
await next();
|
||
});
|
||
}
|
||
|
||
app.MapStaticAssets();
|
||
app.MapHub<NexusReader.Infrastructure.RealTime.SyncHub>("/synchub");
|
||
|
||
// API endpoint for WASM client to fetch EPUB content
|
||
app.MapGet("/api/epub/{ebookId:guid}/{index:int}", async (Guid ebookId, int index, IEpubReader epubService, ClaimsPrincipal user) =>
|
||
{
|
||
var userId = user.FindFirstValue(ClaimTypes.NameIdentifier);
|
||
var result = await epubService.GetEpubContentAsync(ebookId, index, userId);
|
||
|
||
if (result.IsSuccess) return Results.Ok(result.Value);
|
||
|
||
var errorMsg = result.Errors.Count > 0 ? result.Errors[0].Message : "Unknown server error";
|
||
return Results.BadRequest(errorMsg);
|
||
}).RequireAuthorization();
|
||
|
||
// API endpoint for WASM client/browser to fetch EPUB static resources (images, etc.)
|
||
app.MapGet("/api/epub/{ebookId:guid}/resource", async (Guid ebookId, string path, IEpubReader epubService, ClaimsPrincipal user, HttpContext httpContext, CancellationToken cancellationToken) =>
|
||
{
|
||
if (string.IsNullOrEmpty(path))
|
||
{
|
||
return Results.BadRequest("Path parameter is required.");
|
||
}
|
||
|
||
var decodedPath = Uri.UnescapeDataString(path);
|
||
if (decodedPath.Contains("..") || decodedPath.Contains(":") || decodedPath.StartsWith("/") || decodedPath.StartsWith("\\"))
|
||
{
|
||
return Results.BadRequest("Invalid resource path.");
|
||
}
|
||
|
||
var userId = user.FindFirstValue(ClaimTypes.NameIdentifier);
|
||
var result = await epubService.GetEpubResourceAsync(ebookId, decodedPath, userId, cancellationToken);
|
||
|
||
if (result.IsSuccess)
|
||
{
|
||
// Serve with client-side caching to avoid redundant roundtrips on chapter navigation
|
||
httpContext.Response.Headers.CacheControl = "public, max-age=86400";
|
||
|
||
var ext = Path.GetExtension(decodedPath).ToLowerInvariant();
|
||
var contentType = ext switch
|
||
{
|
||
".jpg" or ".jpeg" => "image/jpeg",
|
||
".png" => "image/png",
|
||
".gif" => "image/gif",
|
||
".svg" => "image/svg+xml",
|
||
".webp" => "image/webp",
|
||
".css" => "text/css",
|
||
".otf" => "font/otf",
|
||
".ttf" => "font/ttf",
|
||
".woff" => "font/woff",
|
||
".woff2" => "font/woff2",
|
||
_ => "application/octet-stream"
|
||
};
|
||
return Results.File(result.Value, contentType);
|
||
}
|
||
|
||
var errorMsg = result.Errors.Count > 0 ? result.Errors[0].Message : "Resource not found";
|
||
return Results.NotFound(errorMsg);
|
||
}).RequireAuthorization();
|
||
|
||
var knowledgeApi = app.MapGroup("/api/knowledge")
|
||
.RequireAuthorization("HasAvailableTokens")
|
||
.DisableAntiforgery();
|
||
|
||
knowledgeApi.MapPost("/", async (KnowledgeRequest request, ClaimsPrincipal user, IKnowledgeService knowledgeService) =>
|
||
{
|
||
var tenantId = user.FindFirstValue("TenantId") ?? "global";
|
||
var result = await knowledgeService.GetKnowledgeAsync(request.Text, tenantId, request.EbookId);
|
||
if (result.IsSuccess) return Results.Ok(result.Value);
|
||
return Results.BadRequest(result.Errors.Count > 0 ? result.Errors[0].Message : "Unknown server error");
|
||
});
|
||
|
||
knowledgeApi.MapPost("/graph", async (KnowledgeRequest request, ClaimsPrincipal user, IKnowledgeService knowledgeService) =>
|
||
{
|
||
var tenantId = user.FindFirstValue("TenantId") ?? "global";
|
||
var result = await knowledgeService.GetGraphDataAsync(request.Text, tenantId, request.EbookId);
|
||
if (result.IsSuccess) return Results.Ok(result.Value);
|
||
return Results.BadRequest(result.Errors.Count > 0 ? result.Errors[0].Message : "Unknown server error");
|
||
});
|
||
|
||
knowledgeApi.MapPost("/summary", async (KnowledgeRequest request, ClaimsPrincipal user, IKnowledgeService knowledgeService) =>
|
||
{
|
||
var tenantId = user.FindFirstValue("TenantId") ?? "global";
|
||
var result = await knowledgeService.GetSummaryAndQuizAsync(request.Text, tenantId, request.EbookId);
|
||
if (result.IsSuccess) return Results.Ok(result.Value);
|
||
return Results.BadRequest(result.Errors.Count > 0 ? result.Errors[0].Message : "Unknown server error");
|
||
});
|
||
|
||
knowledgeApi.MapPost("/map", async (KnowledgeRequest request, ClaimsPrincipal user, IKnowledgeService knowledgeService) =>
|
||
{
|
||
var tenantId = user.FindFirstValue("TenantId") ?? "global";
|
||
var result = await knowledgeService.GetKnowledgeMapAsync(request.Text, tenantId, request.EbookId);
|
||
if (result.IsSuccess) return Results.Ok(result.Value);
|
||
return Results.BadRequest(result.Errors.Count > 0 ? result.Errors[0].Message : "Unknown server error");
|
||
});
|
||
|
||
knowledgeApi.MapPost("/verify-groundedness", async (GroundednessRequest request, ClaimsPrincipal user, IKnowledgeService knowledgeService) =>
|
||
{
|
||
var tenantId = user.FindFirstValue("TenantId") ?? "global";
|
||
var result = await knowledgeService.VerifyGroundednessAsync(request.Answer, request.Context, tenantId);
|
||
if (result.IsSuccess) return Results.Ok(result.Value);
|
||
return Results.BadRequest(result.Errors.Count > 0 ? result.Errors[0].Message : "Unknown server error");
|
||
});
|
||
|
||
knowledgeApi.MapPost("/search", async (SemanticSearchRequest request, ClaimsPrincipal user, IKnowledgeService knowledgeService) =>
|
||
{
|
||
var tenantId = user.FindFirstValue("TenantId") ?? "global";
|
||
var result = await knowledgeService.SearchLibrarySemanticallyAsync(request.QueryText, tenantId, request.Limit);
|
||
if (result.IsSuccess) return Results.Ok(result.Value);
|
||
return Results.BadRequest(result.Errors.Count > 0 ? result.Errors[0].Message : "Unknown server error");
|
||
});
|
||
|
||
knowledgeApi.MapPost("/ask", async (AskQuestionRequest request, ClaimsPrincipal user, IKnowledgeService knowledgeService) =>
|
||
{
|
||
var tenantId = user.FindFirstValue("TenantId") ?? "global";
|
||
var result = await knowledgeService.AskQuestionAsync(request.Question, tenantId, request.EbookId, request.Limit);
|
||
if (result.IsSuccess) return Results.Ok(result.Value);
|
||
return Results.BadRequest(result.Errors.Count > 0 ? result.Errors[0].Message : "Unknown server error");
|
||
});
|
||
|
||
knowledgeApi.MapDelete("/", async (IKnowledgeService knowledgeService) =>
|
||
{
|
||
var result = await knowledgeService.ClearCacheAsync();
|
||
if (result.IsSuccess) return Results.Ok();
|
||
|
||
var errorMsg = result.Errors.Count > 0 ? result.Errors[0].Message : "Unknown server error";
|
||
return Results.BadRequest(errorMsg);
|
||
});
|
||
|
||
app.MapPost("/api/intelligence", async (
|
||
[FromBody] NexusReader.Application.Queries.Intelligence.GetGlobalIntelligenceRequest request,
|
||
ClaimsPrincipal user,
|
||
IMediator mediator) =>
|
||
{
|
||
var userId = user.FindFirstValue(ClaimTypes.NameIdentifier);
|
||
if (string.IsNullOrEmpty(userId)) return Results.Unauthorized();
|
||
|
||
var tenantId = user.FindFirstValue("TenantId") ?? "global";
|
||
|
||
var result = await mediator.Send(new NexusReader.Application.Queries.Intelligence.GetGlobalIntelligenceQuery(request.QueryText, userId, tenantId));
|
||
if (result.IsSuccess) return Results.Ok(result.Value);
|
||
|
||
var errorMsg = result.Errors.Count > 0 ? result.Errors[0].Message : "Failed to execute global intelligence query";
|
||
return Results.BadRequest(errorMsg);
|
||
}).RequireAuthorization();
|
||
|
||
app.MapGet("/api/recommendations", async (
|
||
ClaimsPrincipal user,
|
||
IMediator mediator) =>
|
||
{
|
||
var userId = user.FindFirstValue(ClaimTypes.NameIdentifier);
|
||
if (string.IsNullOrEmpty(userId)) return Results.Unauthorized();
|
||
|
||
var result = await mediator.Send(new NexusReader.Application.Queries.Recommendations.GetContextualRecommendationsQuery(userId));
|
||
if (result.IsSuccess) return Results.Ok(result.Value);
|
||
|
||
var errorMsg = result.Errors.Count > 0 ? result.Errors[0].Message : "Failed to fetch contextual recommendations";
|
||
return Results.BadRequest(errorMsg);
|
||
}).RequireAuthorization();
|
||
|
||
app.MapPost("/api/library/ingest", async ([FromBody] IngestEbookRequest request, ClaimsPrincipal user, IMediator mediator) =>
|
||
{
|
||
var userId = user.FindFirstValue(ClaimTypes.NameIdentifier);
|
||
if (string.IsNullOrEmpty(userId)) return Results.Unauthorized();
|
||
|
||
var epubData = Convert.FromBase64String(request.EpubDataBase64);
|
||
byte[]? coverData = !string.IsNullOrEmpty(request.CoverImageBase64)
|
||
? Convert.FromBase64String(request.CoverImageBase64)
|
||
: null;
|
||
|
||
var tenantId = user.FindFirst("TenantId")?.Value ?? "global";
|
||
|
||
var command = new IngestEbookCommand(
|
||
request.Title,
|
||
request.AuthorName,
|
||
coverData,
|
||
epubData,
|
||
request.Description,
|
||
userId,
|
||
tenantId
|
||
);
|
||
|
||
var result = await mediator.Send(command);
|
||
if (result.IsSuccess) return Results.Ok(new { Id = result.Value });
|
||
|
||
return Results.BadRequest(result.Errors.FirstOrDefault()?.Message ?? "Ingestion failed");
|
||
}).RequireAuthorization().DisableAntiforgery();
|
||
|
||
app.MapGet("/api/library/books", async (ClaimsPrincipal user, IMediator mediator) =>
|
||
{
|
||
var userId = user.FindFirstValue(ClaimTypes.NameIdentifier);
|
||
if (string.IsNullOrEmpty(userId)) return Results.Unauthorized();
|
||
|
||
var result = await mediator.Send(new GetMyEbooksQuery(userId));
|
||
if (result.IsSuccess) return Results.Ok(result.Value);
|
||
|
||
var errorMsg = result.Errors.Count > 0 ? result.Errors[0].Message : "Unknown server error";
|
||
return Results.BadRequest(errorMsg);
|
||
}).RequireAuthorization();
|
||
|
||
app.MapPost("/api/library/purchase", async (
|
||
ClaimsPrincipal user,
|
||
[FromBody] PurchaseBookRequest request,
|
||
IDbContextFactory<AppDbContext> dbContextFactory) =>
|
||
{
|
||
var userId = user.FindFirstValue(ClaimTypes.NameIdentifier);
|
||
if (string.IsNullOrEmpty(userId)) return Results.Unauthorized();
|
||
|
||
using var dbContext = await dbContextFactory.CreateDbContextAsync();
|
||
|
||
// Find or create author
|
||
var authorName = "Nexus Architect";
|
||
var author = await dbContext.Authors.FirstOrDefaultAsync(a => a.Name == authorName);
|
||
if (author == null)
|
||
{
|
||
author = new Author { Name = authorName };
|
||
dbContext.Authors.Add(author);
|
||
await dbContext.SaveChangesAsync();
|
||
}
|
||
|
||
// Check if the book already exists for the user
|
||
var bookExists = await dbContext.Ebooks.AnyAsync(e => e.UserId == userId && e.Title == request.Title);
|
||
if (!bookExists)
|
||
{
|
||
var newBook = new Ebook
|
||
{
|
||
Title = request.Title,
|
||
AuthorId = author.Id,
|
||
UserId = userId,
|
||
FilePath = "wwwroot/assets/book.epub",
|
||
AddedDate = DateTime.UtcNow,
|
||
Progress = 0,
|
||
Description = "Zaawansowany kurs budowania skalowalnych SaaS z Native AOT, CQRS, MediatR, FluentResults i izolowanym systemem stylów Blazor CSS.",
|
||
IsReadyForReading = true
|
||
};
|
||
dbContext.Ebooks.Add(newBook);
|
||
await dbContext.SaveChangesAsync();
|
||
}
|
||
|
||
return Results.Ok();
|
||
}).RequireAuthorization();
|
||
|
||
app.MapGet("/api/book/{bookId:guid}/concepts-map", async (
|
||
Guid bookId,
|
||
ClaimsPrincipal user,
|
||
IMediator mediator) =>
|
||
{
|
||
var userId = user.FindFirstValue(ClaimTypes.NameIdentifier);
|
||
var tenantId = user.FindFirstValue("TenantId") ?? "global";
|
||
|
||
if (string.IsNullOrEmpty(userId))
|
||
{
|
||
return Results.Unauthorized();
|
||
}
|
||
|
||
var result = await mediator.Send(new GetBookConceptsMapQuery(bookId, userId, tenantId));
|
||
if (result.IsFailed)
|
||
{
|
||
return Results.BadRequest(result.Errors.FirstOrDefault()?.Message ?? "Failed to fetch concepts map.");
|
||
}
|
||
|
||
return Results.Ok(result.Value);
|
||
}).RequireAuthorization();
|
||
|
||
app.MapPost("/api/StripeWebhook", async (
|
||
HttpContext context,
|
||
UserManager<NexusUser> userManager,
|
||
IConfiguration configuration,
|
||
IDbContextFactory<AppDbContext> dbContextFactory) =>
|
||
{
|
||
using var dbContext = await dbContextFactory.CreateDbContextAsync();
|
||
var json = await new StreamReader(context.Request.Body).ReadToEndAsync();
|
||
var webhookSecret = configuration["Stripe:WebhookSecret"] ?? "";
|
||
|
||
try
|
||
{
|
||
var stripeEvent = EventUtility.ConstructEvent(
|
||
json,
|
||
context.Request.Headers["Stripe-Signature"],
|
||
webhookSecret
|
||
);
|
||
|
||
switch (stripeEvent.Type)
|
||
{
|
||
case EventTypes.CheckoutSessionCompleted:
|
||
var session = stripeEvent.Data.Object as Stripe.Checkout.Session;
|
||
await HandleSubscriptionSuccess(session?.CustomerEmail, session?.Metadata, userManager, dbContext);
|
||
break;
|
||
|
||
case EventTypes.CustomerSubscriptionUpdated:
|
||
var subscription = stripeEvent.Data.Object as Stripe.Subscription;
|
||
await HandleSubscriptionSuccess(subscription?.Metadata["CustomerEmail"], subscription?.Metadata, userManager, dbContext);
|
||
break;
|
||
|
||
case EventTypes.CustomerSubscriptionDeleted:
|
||
var deletedSubscription = stripeEvent.Data.Object as Stripe.Subscription;
|
||
await HandleSubscriptionCancellation(deletedSubscription?.Metadata["CustomerEmail"], userManager, dbContext);
|
||
break;
|
||
}
|
||
return Results.Ok();
|
||
}
|
||
catch (StripeException e)
|
||
{
|
||
return Results.BadRequest(e.Message);
|
||
}
|
||
}).DisableAntiforgery();
|
||
|
||
async Task HandleSubscriptionSuccess(
|
||
string? email,
|
||
Dictionary<string, string>? metadata,
|
||
UserManager<NexusUser> userManager,
|
||
AppDbContext dbContext)
|
||
{
|
||
if (string.IsNullOrEmpty(email)) return;
|
||
|
||
var user = await userManager.FindByEmailAsync(email);
|
||
if (user != null)
|
||
{
|
||
var planName = metadata?.GetValueOrDefault("Plan") ?? SubscriptionPlan.ProName;
|
||
var plan = await dbContext.SubscriptionPlans.FirstOrDefaultAsync(p => p.PlanName == planName);
|
||
|
||
if (plan != null)
|
||
{
|
||
user.SubscriptionPlanId = plan.Id;
|
||
user.AITokenLimit = plan.AITokenLimit;
|
||
}
|
||
|
||
await userManager.UpdateAsync(user);
|
||
}
|
||
}
|
||
|
||
async Task HandleSubscriptionCancellation(
|
||
string? email,
|
||
UserManager<NexusUser> userManager,
|
||
AppDbContext dbContext)
|
||
{
|
||
if (string.IsNullOrEmpty(email)) return;
|
||
|
||
var user = await userManager.FindByEmailAsync(email);
|
||
if (user != null)
|
||
{
|
||
var freePlan = await dbContext.SubscriptionPlans.FindAsync(SubscriptionPlan.FreeId);
|
||
user.SubscriptionPlanId = SubscriptionPlan.FreeId;
|
||
user.AITokenLimit = freePlan?.AITokenLimit ?? 5000;
|
||
await userManager.UpdateAsync(user);
|
||
}
|
||
}
|
||
|
||
app.MapGroup("/identity").MapIdentityApi<NexusUser>();
|
||
|
||
app.MapGet("/identity/login/google", (string? returnUrl) =>
|
||
{
|
||
var properties = new AuthenticationProperties
|
||
{
|
||
RedirectUri = "/identity/callback/google",
|
||
Items = { { "returnUrl", string.IsNullOrEmpty(returnUrl) ? "/" : returnUrl } }
|
||
};
|
||
return Results.Challenge(properties, new[] { "Google" });
|
||
});
|
||
|
||
app.MapGet("/identity/callback/google", async (
|
||
HttpContext context,
|
||
SignInManager<NexusUser> signInManager,
|
||
UserManager<NexusUser> userManager,
|
||
ILogger<Program> logger) =>
|
||
{
|
||
var info = await signInManager.GetExternalLoginInfoAsync();
|
||
if (info == null)
|
||
{
|
||
logger.LogWarning("External login info from Google is null.");
|
||
return Results.Redirect("/account/login?error=ExternalLoginFailed");
|
||
}
|
||
|
||
var result = await signInManager.ExternalLoginSignInAsync(info.LoginProvider, info.ProviderKey, isPersistent: false);
|
||
if (result.Succeeded)
|
||
{
|
||
logger.LogInformation("User logged in via Google: {Email}", info.Principal.FindFirstValue(ClaimTypes.Email));
|
||
return Results.Redirect("/");
|
||
}
|
||
|
||
if (result.IsLockedOut)
|
||
{
|
||
logger.LogWarning("User account locked out during Google login: {Email}", info.Principal.FindFirstValue(ClaimTypes.Email));
|
||
return Results.Redirect("/account/login?error=LockedOut");
|
||
}
|
||
|
||
// New user provisioning (blocked when registration is disabled)
|
||
if (!allowRegistration)
|
||
{
|
||
logger.LogWarning("Google provisioning blocked: registration is disabled in this environment.");
|
||
return Results.Redirect("/account/login?error=RegistrationDisabled");
|
||
}
|
||
|
||
var email = info.Principal.FindFirstValue(ClaimTypes.Email);
|
||
if (email != null)
|
||
{
|
||
var user = new NexusUser { UserName = email, Email = email, EmailConfirmed = true };
|
||
var createResult = await userManager.CreateAsync(user);
|
||
|
||
if (createResult.Succeeded)
|
||
{
|
||
await userManager.AddLoginAsync(user, info);
|
||
await signInManager.SignInAsync(user, isPersistent: false);
|
||
logger.LogInformation("New user provisioned via Google: {Email}", email);
|
||
return Results.Redirect("/");
|
||
}
|
||
|
||
// Log specific errors
|
||
foreach (var error in createResult.Errors)
|
||
{
|
||
logger.LogError("Google provisioning failed for {Email}: {Code} - {Description}", email, error.Code, error.Description);
|
||
}
|
||
|
||
if (createResult.Errors.Any(e => e.Code == "DuplicateEmail" || e.Code == "DuplicateUserName"))
|
||
{
|
||
return Results.Redirect("/account/login?error=UserAlreadyExists");
|
||
}
|
||
}
|
||
|
||
logger.LogError("Google provisioning failed - unknown reason for email {Email}", email);
|
||
return Results.Redirect("/account/login?error=ProvisioningFailed");
|
||
});
|
||
|
||
app.MapPost("/account/login-form", async (
|
||
[FromForm] string email,
|
||
[FromForm] string password,
|
||
[FromForm] bool rememberMe,
|
||
[FromForm] string? returnUrl,
|
||
SignInManager<NexusUser> signInManager,
|
||
ILogger<Program> logger) =>
|
||
{
|
||
var result = await signInManager.PasswordSignInAsync(email, password, rememberMe, lockoutOnFailure: true);
|
||
if (result.Succeeded)
|
||
{
|
||
logger.LogInformation("User logged in: {Email}", email);
|
||
return Results.Redirect(string.IsNullOrEmpty(returnUrl) ? "/" : returnUrl);
|
||
}
|
||
|
||
var error = result.IsLockedOut ? "LockedOut" : "InvalidCredentials";
|
||
return Results.Redirect($"/account/login?error={error}");
|
||
}).DisableAntiforgery(); // Simplified for now, in production use proper antiforgery
|
||
|
||
app.MapGet("/account/logout-form", async (
|
||
SignInManager<NexusUser> signInManager,
|
||
ILogger<Program> logger) =>
|
||
{
|
||
await signInManager.SignOutAsync();
|
||
logger.LogInformation("User logged out via form.");
|
||
return Results.Redirect("/account/login");
|
||
});
|
||
|
||
app.MapGet("/identity/profile", async (ClaimsPrincipal user, IMediator mediator) =>
|
||
{
|
||
var userId = user.FindFirstValue(ClaimTypes.NameIdentifier);
|
||
if (userId == null) return Results.Unauthorized();
|
||
|
||
var result = await mediator.Send(new GetUserProfileQuery(userId));
|
||
if (result.IsFailed) return Results.NotFound(result.Errors.FirstOrDefault()?.Message);
|
||
|
||
return Results.Ok(result.Value);
|
||
}).RequireAuthorization();
|
||
|
||
app.MapRazorComponents<App>()
|
||
.AddInteractiveServerRenderMode()
|
||
.AddInteractiveWebAssemblyRenderMode()
|
||
.AddAdditionalAssemblies(typeof(NexusReader.UI.Shared.Services.IKnowledgeGraphService).Assembly);
|
||
|
||
app.Run();
|
||
|
||
async Task TriggerBackgroundProcessingForUnindexedBooksAsync(IServiceProvider services)
|
||
{
|
||
var logger = services.GetRequiredService<ILogger<Program>>();
|
||
try
|
||
{
|
||
var dbContextFactory = services.GetRequiredService<IDbContextFactory<NexusReader.Data.Persistence.AppDbContext>>();
|
||
using var dbContext = await dbContextFactory.CreateDbContextAsync();
|
||
|
||
var unindexedEbooks = await dbContext.Ebooks
|
||
.Where(e => !e.IsReadyForReading)
|
||
.ToListAsync();
|
||
|
||
if (unindexedEbooks.Any())
|
||
{
|
||
logger.LogInformation("[Startup] Found {Count} un-indexed ebooks. Triggering background processing...", unindexedEbooks.Count);
|
||
|
||
foreach (var ebook in unindexedEbooks)
|
||
{
|
||
logger.LogInformation("[Startup] Queuing background processing for ebook: '{Title}' ({Id})", ebook.Title, ebook.Id);
|
||
|
||
_ = Task.Run(async () =>
|
||
{
|
||
try
|
||
{
|
||
using var scope = services.CreateScope();
|
||
var scopedMediator = scope.ServiceProvider.GetRequiredService<IMediator>();
|
||
await scopedMediator.Send(new ProcessEbookCommand(ebook.Id, ebook.UserId, ebook.TenantId));
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
using var scope = services.CreateScope();
|
||
var scopedLogger = scope.ServiceProvider.GetRequiredService<ILogger<Program>>();
|
||
scopedLogger.LogError(ex, "Failed to run background processing for ebook {EbookId} on startup", ebook.Id);
|
||
}
|
||
});
|
||
}
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
logger.LogError(ex, "Error checking or triggering background processing for unindexed books on startup.");
|
||
}
|
||
}
|
||
|
||
public record KnowledgeRequest(string Text, Guid? EbookId = null);
|
||
public record GroundednessRequest(string Answer, string Context);
|
||
public record SemanticSearchRequest(string QueryText, int Limit = 5);
|
||
public record AskQuestionRequest(string Question, Guid? EbookId = null, int Limit = 5);
|
||
public record PurchaseBookRequest(string Title);
|