diff --git a/Directory.Packages.props b/Directory.Packages.props
index 7cef88e..daa4de1 100644
--- a/Directory.Packages.props
+++ b/Directory.Packages.props
@@ -27,6 +27,11 @@
+
+
+
+
+
diff --git a/Tiku.Api/Caching/TenantPublicCacheInvalidator.cs b/Tiku.Api/Caching/TenantPublicCacheInvalidator.cs
new file mode 100644
index 0000000..7d9d8f5
--- /dev/null
+++ b/Tiku.Api/Caching/TenantPublicCacheInvalidator.cs
@@ -0,0 +1,14 @@
+using Microsoft.AspNetCore.OutputCaching;
+using Tiku.Application.Tenancy;
+
+namespace Tiku.Api.Caching;
+
+internal sealed class TenantPublicCacheInvalidator(IOutputCacheStore outputCacheStore)
+ : ITenantPublicCacheInvalidator
+{
+ public ValueTask InvalidateCoreAsync(Guid tenantId, CancellationToken cancellationToken) =>
+ outputCacheStore.EvictByTagAsync($"tenant:{tenantId:N}", cancellationToken);
+
+ public async Task InvalidateAsync(Guid tenantId, CancellationToken cancellationToken = default) =>
+ await InvalidateCoreAsync(tenantId, cancellationToken);
+}
diff --git a/Tiku.Api/Caching/TenantPublicOutputCachePolicy.cs b/Tiku.Api/Caching/TenantPublicOutputCachePolicy.cs
new file mode 100644
index 0000000..9ff7feb
--- /dev/null
+++ b/Tiku.Api/Caching/TenantPublicOutputCachePolicy.cs
@@ -0,0 +1,48 @@
+using Microsoft.AspNetCore.OutputCaching;
+using Microsoft.Extensions.Primitives;
+using Tiku.Application.Security;
+
+namespace Tiku.Api.Caching;
+
+internal sealed class TenantPublicOutputCachePolicy : IOutputCachePolicy
+{
+ public ValueTask CacheRequestAsync(OutputCacheContext context, CancellationToken cancellationToken)
+ {
+ var request = context.HttpContext.Request;
+ var tenantId = context.HttpContext.RequestServices.GetRequiredService().TenantId;
+ var enabled = HttpMethods.IsGet(request.Method) &&
+ tenantId.HasValue &&
+ StringValues.IsNullOrEmpty(request.Headers.Authorization) &&
+ context.HttpContext.User.Identity?.IsAuthenticated != true;
+ context.EnableOutputCaching = enabled;
+ context.AllowCacheLookup = enabled;
+ context.AllowCacheStorage = enabled;
+ context.AllowLocking = true;
+ if (enabled)
+ {
+ var resolvedTenantId = tenantId.GetValueOrDefault();
+ context.CacheVaryByRules.QueryKeys = "*";
+ context.CacheVaryByRules.HeaderNames = new StringValues("Accept-Encoding");
+ context.CacheVaryByRules.VaryByValues["tenant"] = resolvedTenantId.ToString("N");
+ context.Tags.Add($"tenant:{resolvedTenantId:N}");
+ }
+
+ return ValueTask.CompletedTask;
+ }
+
+ public ValueTask ServeFromCacheAsync(OutputCacheContext context, CancellationToken cancellationToken) =>
+ ValueTask.CompletedTask;
+
+ public ValueTask ServeResponseAsync(OutputCacheContext context, CancellationToken cancellationToken)
+ {
+ var response = context.HttpContext.Response;
+ if (response.StatusCode != StatusCodes.Status200OK ||
+ !StringValues.IsNullOrEmpty(response.Headers.SetCookie) ||
+ context.HttpContext.User.Identity?.IsAuthenticated == true)
+ {
+ context.AllowCacheStorage = false;
+ }
+
+ return ValueTask.CompletedTask;
+ }
+}
diff --git a/Tiku.Api/Configuration/ApplicationBuilderExtensions.cs b/Tiku.Api/Configuration/ApplicationBuilderExtensions.cs
index 5a3ec18..533216d 100644
--- a/Tiku.Api/Configuration/ApplicationBuilderExtensions.cs
+++ b/Tiku.Api/Configuration/ApplicationBuilderExtensions.cs
@@ -22,9 +22,11 @@ public static class ApplicationBuilderExtensions
}
app.UseSerilogRequestLogging(SerilogRequestLogging.ConfigureRequestLogging);
+ app.UseMiddleware();
app.UseMiddleware();
app.UseForwardedHeaders();
app.UseHttpsRedirection();
+ app.UseResponseCompression();
app.UseDefaultFiles();
app.UseStaticFiles();
app.UseRouting();
@@ -37,6 +39,7 @@ public static class ApplicationBuilderExtensions
app.UseMiddleware();
app.UseAuthorization();
app.UseMiddleware();
+ app.UseOutputCache();
app.MapControllers();
return app;
diff --git a/Tiku.Api/Configuration/AuthenticationExtensions.cs b/Tiku.Api/Configuration/AuthenticationExtensions.cs
index 3dbed39..1ce0bc1 100644
--- a/Tiku.Api/Configuration/AuthenticationExtensions.cs
+++ b/Tiku.Api/Configuration/AuthenticationExtensions.cs
@@ -209,7 +209,11 @@ internal static class AuthenticationExtensions
if (session is null)
{
context.Fail("Session, identity, membership, tenant or role state is no longer valid.");
+ return;
}
+
+ context.HttpContext.RequestServices.GetRequiredService()
+ .SetValidatedSession(session);
}
private static async Task WriteTenantConflictChallengeAsync(JwtBearerChallengeContext context)
diff --git a/Tiku.Api/Configuration/DependencyInjection.cs b/Tiku.Api/Configuration/DependencyInjection.cs
index 58d7aed..4eba680 100644
--- a/Tiku.Api/Configuration/DependencyInjection.cs
+++ b/Tiku.Api/Configuration/DependencyInjection.cs
@@ -3,6 +3,12 @@ using Tiku.Application;
using Tiku.Infrastructure;
using Tiku.Infrastructure.Messaging;
using Tiku.Infrastructure.Security;
+using Tiku.Api.Caching;
+using Microsoft.AspNetCore.ResponseCompression;
+using System.IO.Compression;
+using Tiku.Api.Observability;
+using Tiku.Application.Tenancy;
+using Microsoft.Extensions.DependencyInjection.Extensions;
namespace Tiku.Api.Configuration;
@@ -18,6 +24,9 @@ public static class DependencyInjection
builder.Services.AddApiPresentation();
builder.Services.AddHealthChecks();
+ builder.Services.AddApiObservability(builder.Configuration, builder.Environment);
+ builder.Services.AddSingleton();
+ builder.Services.AddHostedService();
builder.Services.AddApplication();
builder.Services.AddNetworkConfiguration(builder.Configuration, builder.Environment);
builder.Services.AddApiRateLimiting(builder.Configuration);
@@ -42,6 +51,31 @@ public static class DependencyInjection
throw new InvalidOperationException(
"Redis is required in Production. Configure ConnectionStrings:Redis or REDIS_URL.");
}
+
+ builder.Services.AddOutputCache(options =>
+ {
+ options.AddPolicy("TenantPublic", new TenantPublicOutputCachePolicy());
+ options.DefaultExpirationTimeSpan = TimeSpan.FromSeconds(60);
+ });
+ builder.Services.RemoveAll();
+ builder.Services.AddSingleton();
+ if (builder.Environment.IsProduction() && !string.IsNullOrWhiteSpace(redisConnectionString))
+ {
+ builder.Services.AddStackExchangeRedisOutputCache(options =>
+ {
+ options.Configuration = redisConnectionString;
+ options.InstanceName = $"tiku:{builder.Environment.EnvironmentName.ToLowerInvariant()}:output:";
+ });
+ }
+ builder.Services.AddResponseCompression(options =>
+ {
+ options.EnableForHttps = true;
+ options.Providers.Add();
+ options.Providers.Add();
+ options.MimeTypes = ResponseCompressionDefaults.MimeTypes.Concat(["application/json"]);
+ });
+ builder.Services.Configure(options => options.Level = CompressionLevel.Fastest);
+ builder.Services.Configure(options => options.Level = CompressionLevel.Fastest);
var messaging = builder.Configuration.GetSection("RabbitMq").Get() ?? new MessagingOptions();
builder.Services.AddOptions()
.Bind(builder.Configuration.GetSection("RabbitMq"))
diff --git a/Tiku.Api/Configuration/ObservabilityExtensions.cs b/Tiku.Api/Configuration/ObservabilityExtensions.cs
new file mode 100644
index 0000000..69d4b27
--- /dev/null
+++ b/Tiku.Api/Configuration/ObservabilityExtensions.cs
@@ -0,0 +1,46 @@
+using OpenTelemetry.Metrics;
+using OpenTelemetry.Resources;
+using OpenTelemetry.Trace;
+using Tiku.Infrastructure.Observability;
+
+namespace Tiku.Api.Configuration;
+
+internal static class ObservabilityExtensions
+{
+ internal static IServiceCollection AddApiObservability(
+ this IServiceCollection services,
+ IConfiguration configuration,
+ IHostEnvironment environment)
+ {
+ var endpoint = configuration["OpenTelemetry:OtlpEndpoint"];
+ var hasOtlpEndpoint = Uri.TryCreate(endpoint, UriKind.Absolute, out var endpointUri);
+
+ services.AddOpenTelemetry()
+ .ConfigureResource(resource => resource.AddService(
+ serviceName: environment.ApplicationName,
+ serviceVersion: typeof(ObservabilityExtensions).Assembly.GetName().Version?.ToString()))
+ .WithTracing(tracing => tracing
+ .AddAspNetCoreInstrumentation(options =>
+ options.Filter = context => !context.Request.Path.StartsWithSegments("/api/health"))
+ .AddHttpClientInstrumentation()
+ .AddSource("Npgsql")
+ .ApplyIf(hasOtlpEndpoint, builder => builder.AddOtlpExporter(options => options.Endpoint = endpointUri!)))
+ .WithMetrics(metrics => metrics
+ .AddAspNetCoreInstrumentation()
+ .AddHttpClientInstrumentation()
+ .AddMeter(DatabasePerformanceTelemetry.MeterName, "Tiku.Security.Redis", "Tiku.Messaging", "Npgsql")
+ .ApplyIf(hasOtlpEndpoint, builder => builder.AddOtlpExporter(options => options.Endpoint = endpointUri!)));
+
+ return services;
+ }
+
+ private static TBuilder ApplyIf(this TBuilder builder, bool condition, Action configure)
+ {
+ if (condition)
+ {
+ configure(builder);
+ }
+
+ return builder;
+ }
+}
diff --git a/Tiku.Api/Contracts/ScorelineDtos.cs b/Tiku.Api/Contracts/ScorelineDtos.cs
index e3a35a3..195b1ab 100644
--- a/Tiku.Api/Contracts/ScorelineDtos.cs
+++ b/Tiku.Api/Contracts/ScorelineDtos.cs
@@ -57,6 +57,12 @@ public sealed class ScorelineQueryDto
[Range(1, 2000)]
public int? Limit { get; set; }
+ ///
+ /// 版本化的不透明游标，仅用于游标分页接口。
+ ///
+ [StringLength(2000)]
+ public string? Cursor { get; set; }
+
public ScorelineFilter ToFilter(
Guid tenantId,
IReadOnlyCollection? dynamicFilters = null)
diff --git a/Tiku.Api/Controllers/CatalogController.cs b/Tiku.Api/Controllers/CatalogController.cs
index 1dff021..3f593d4 100644
--- a/Tiku.Api/Controllers/CatalogController.cs
+++ b/Tiku.Api/Controllers/CatalogController.cs
@@ -1,5 +1,6 @@
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.OutputCaching;
using Microsoft.EntityFrameworkCore;
using Tiku.Application.Assets;
using Tiku.Api.Contracts;
@@ -18,6 +19,7 @@ namespace Tiku.Api.Controllers;
[AllowAnonymous]
[Produces("application/json")]
[Route("api/catalog")]
+[OutputCache(PolicyName = "TenantPublic")]
public sealed class CatalogController(
ICatalogQueryService catalogQueryService,
IContentNavigationQueryService contentNavigationQueryService,
diff --git a/Tiku.Api/Controllers/HealthController.cs b/Tiku.Api/Controllers/HealthController.cs
index e49aba5..e9f9ebf 100644
--- a/Tiku.Api/Controllers/HealthController.cs
+++ b/Tiku.Api/Controllers/HealthController.cs
@@ -4,9 +4,9 @@ using Tiku.Api.Contracts;
using Tiku.Application.Security;
using Tiku.Infrastructure.Persistence;
using Microsoft.EntityFrameworkCore;
-using MassTransit.EntityFrameworkCoreIntegration;
using Microsoft.Extensions.Diagnostics.HealthChecks;
using Tiku.Infrastructure.Messaging;
+using Tiku.Api.Observability;
namespace Tiku.Api.Controllers;
@@ -19,7 +19,8 @@ public sealed class HealthController(
TikuDbContext dbContext,
IRedisSecurityStore redisSecurityStore,
MessagingOptions messagingOptions,
- HealthCheckService healthCheckService) : ControllerBase
+ HealthCheckService healthCheckService,
+ OutboxBacklogSnapshot outboxSnapshot) : ControllerBase
{
[HttpGet]
[EndpointSummary("健康检查")]
@@ -43,17 +44,8 @@ public sealed class HealthController(
registration => registration.Tags.Contains("ready"),
cancellationToken);
var rabbitMq = !messagingOptions.IsConfigured || rabbitHealth.Status == HealthStatus.Healthy;
- var outboxPending = database
- ? await dbContext.Set().CountAsync(cancellationToken)
- : -1;
- var outboxOldestSentTime = database
- ? await dbContext.Set()
- .Select(message => (DateTime?)message.SentTime)
- .MinAsync(cancellationToken)
- : null;
- var outboxOldestAgeSeconds = outboxOldestSentTime is null
- ? 0
- : Math.Max(0, (DateTimeOffset.UtcNow - new DateTimeOffset(outboxOldestSentTime.Value)).TotalSeconds);
+ var outboxPending = outboxSnapshot.Pending;
+ var outboxOldestAgeSeconds = outboxSnapshot.OldestAgeSeconds;
var outboxAlert = outboxPending >= messagingOptions.OutboxBacklogAlertCount ||
outboxOldestAgeSeconds >= messagingOptions.OutboxOldestMessageAlertSeconds;
var ready = database && redis && rabbitMq;
diff --git a/Tiku.Api/Controllers/RuntimeController.cs b/Tiku.Api/Controllers/RuntimeController.cs
index cfe6db2..7004a67 100644
--- a/Tiku.Api/Controllers/RuntimeController.cs
+++ b/Tiku.Api/Controllers/RuntimeController.cs
@@ -1,5 +1,6 @@
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.OutputCaching;
using Tiku.Application.Security;
using Tiku.Application.Tenancy;
@@ -15,6 +16,7 @@ public sealed class RuntimeController(
ITenantFrontendConfigService frontendConfigService) : ControllerBase
{
[HttpGet("bootstrap")]
+ [OutputCache(PolicyName = "TenantPublic")]
[EndpointSummary("获取租户前端运行时配置")]
[ProducesResponseType(StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status304NotModified)]
diff --git a/Tiku.Api/Controllers/ScorelineController.cs b/Tiku.Api/Controllers/ScorelineController.cs
index e0a4e12..3c001eb 100644
--- a/Tiku.Api/Controllers/ScorelineController.cs
+++ b/Tiku.Api/Controllers/ScorelineController.cs
@@ -1,5 +1,6 @@
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.OutputCaching;
using Microsoft.EntityFrameworkCore;
using Tiku.Api.Contracts;
using Tiku.Application.Catalog;
@@ -24,6 +25,7 @@ public sealed class ScorelineController(
private static readonly string[] DynamicPrefixes = ["field.", "min.", "max."];
[HttpGet("fields")]
+ [OutputCache(PolicyName = "TenantPublic")]
[EndpointSummary("查询分数线字段配置")]
[ProducesResponseType>(StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status404NotFound)]
@@ -49,6 +51,20 @@ public sealed class ScorelineController(
cancellationToken));
}
+ [HttpGet("records/cursor")]
+ [EndpointSummary("游标分页查询分数线记录")]
+ [ProducesResponseType(StatusCodes.Status200OK)]
+ [ProducesResponseType(StatusCodes.Status400BadRequest)]
+ public async Task> GetRecordsCursor(
+ [FromQuery] ScorelineQueryDto query,
+ CancellationToken cancellationToken)
+ {
+ return Ok(await scorelineQueryService.GetRecordsCursorAsync(
+ query.ToFilter(await ResolveTenantIdAsync(query, cancellationToken), ResolveDynamicFilters()),
+ query.Cursor,
+ cancellationToken));
+ }
+
[HttpGet("trend")]
[EndpointSummary("查询历年分数线趋势")]
[ProducesResponseType>(StatusCodes.Status200OK)]
@@ -63,6 +79,7 @@ public sealed class ScorelineController(
}
[HttpGet("years")]
+ [OutputCache(PolicyName = "TenantPublic")]
[EndpointSummary("查询分数线可用年份")]
[ProducesResponseType>(StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status404NotFound)]
diff --git a/Tiku.Api/Middleware/DatabaseRequestMetricsMiddleware.cs b/Tiku.Api/Middleware/DatabaseRequestMetricsMiddleware.cs
new file mode 100644
index 0000000..41b18f7
--- /dev/null
+++ b/Tiku.Api/Middleware/DatabaseRequestMetricsMiddleware.cs
@@ -0,0 +1,12 @@
+using Tiku.Infrastructure.Observability;
+
+namespace Tiku.Api.Middleware;
+
+public sealed class DatabaseRequestMetricsMiddleware(RequestDelegate next)
+{
+ public async Task InvokeAsync(HttpContext context)
+ {
+ using var metrics = DatabaseRequestMetrics.Begin();
+ await next(context);
+ }
+}
diff --git a/Tiku.Api/Observability/OutboxBacklogMonitor.cs b/Tiku.Api/Observability/OutboxBacklogMonitor.cs
new file mode 100644
index 0000000..33a30b4
--- /dev/null
+++ b/Tiku.Api/Observability/OutboxBacklogMonitor.cs
@@ -0,0 +1,66 @@
+using System.Diagnostics.Metrics;
+using Npgsql;
+using Tiku.Infrastructure.Messaging;
+
+namespace Tiku.Api.Observability;
+
+public sealed class OutboxBacklogSnapshot
+{
+ private static readonly Meter Meter = new("Tiku.Messaging", "1.0.0");
+ private long pending;
+ private double oldestAgeSeconds;
+
+ public OutboxBacklogSnapshot()
+ {
+ Meter.CreateObservableGauge("tiku.outbox.pending", () => Interlocked.Read(ref pending));
+ Meter.CreateObservableGauge("tiku.outbox.oldest_age", () => Volatile.Read(ref oldestAgeSeconds), "s");
+ }
+
+ internal long Pending => Interlocked.Read(ref pending);
+ internal double OldestAgeSeconds => Volatile.Read(ref oldestAgeSeconds);
+
+ internal void Update(long count, DateTime? oldestSentTime)
+ {
+ Interlocked.Exchange(ref pending, count);
+ Volatile.Write(ref oldestAgeSeconds, oldestSentTime is null
+ ? 0
+ : Math.Max(0, (DateTimeOffset.UtcNow - new DateTimeOffset(oldestSentTime.Value)).TotalSeconds));
+ }
+}
+
+internal sealed class OutboxBacklogMonitor(
+ NpgsqlDataSource dataSource,
+ OutboxBacklogSnapshot snapshot,
+ MessagingOptions messagingOptions,
+ ILogger logger) : BackgroundService
+{
+ protected override async Task ExecuteAsync(CancellationToken stoppingToken)
+ {
+ while (!stoppingToken.IsCancellationRequested)
+ {
+ try
+ {
+ if (messagingOptions.IsConfigured)
+ {
+ await using var command = dataSource.CreateCommand(
+ "SELECT count(*), min(sent_time) FROM outbox_message;");
+ await using var reader = await command.ExecuteReaderAsync(stoppingToken);
+ if (await reader.ReadAsync(stoppingToken))
+ {
+ snapshot.Update(reader.GetInt64(0), reader.IsDBNull(1) ? null : reader.GetDateTime(1));
+ }
+ }
+ }
+ catch (OperationCanceledException) when (stoppingToken.IsCancellationRequested)
+ {
+ break;
+ }
+ catch (Exception exception)
+ {
+ logger.LogWarning(exception, "Outbox backlog metric collection failed.");
+ }
+
+ await Task.Delay(TimeSpan.FromSeconds(30), stoppingToken);
+ }
+ }
+}
diff --git a/Tiku.Api/Tiku.Api.csproj b/Tiku.Api/Tiku.Api.csproj
index e36de1c..7596c43 100644
--- a/Tiku.Api/Tiku.Api.csproj
+++ b/Tiku.Api/Tiku.Api.csproj
@@ -16,7 +16,12 @@
+
+
+
+
+
diff --git a/Tiku.Api/appsettings.json b/Tiku.Api/appsettings.json
index f57141a..233fe1e 100644
--- a/Tiku.Api/appsettings.json
+++ b/Tiku.Api/appsettings.json
@@ -26,6 +26,9 @@
"Application": "Tiku.Api"
}
},
+ "OpenTelemetry": {
+ "OtlpEndpoint": ""
+ },
"Cors": {
"AllowedOrigins": [],
"AllowedHeaders": [
diff --git a/Tiku.Application/Auth/IRequestSecurityState.cs b/Tiku.Application/Auth/IRequestSecurityState.cs
new file mode 100644
index 0000000..0aacdd7
--- /dev/null
+++ b/Tiku.Application/Auth/IRequestSecurityState.cs
@@ -0,0 +1,24 @@
+namespace Tiku.Application.Auth;
+
+public interface IRequestSecurityState
+{
+ AuthSessionValidationResult? ValidatedSession { get; }
+
+ void SetValidatedSession(AuthSessionValidationResult session);
+}
+
+internal sealed class RequestSecurityState : IRequestSecurityState
+{
+ public AuthSessionValidationResult? ValidatedSession { get; private set; }
+
+ public void SetValidatedSession(AuthSessionValidationResult session)
+ {
+ ArgumentNullException.ThrowIfNull(session);
+ if (ValidatedSession is not null && ValidatedSession != session)
+ {
+ throw new InvalidOperationException("The request security session was already initialized.");
+ }
+
+ ValidatedSession = session;
+ }
+}
diff --git a/Tiku.Application/DependencyInjection.cs b/Tiku.Application/DependencyInjection.cs
index ca867be..268acdf 100644
--- a/Tiku.Application/DependencyInjection.cs
+++ b/Tiku.Application/DependencyInjection.cs
@@ -1,5 +1,6 @@
using Microsoft.Extensions.DependencyInjection;
using Tiku.Application.Security;
+using Tiku.Application.Auth;
namespace Tiku.Application;
@@ -8,6 +9,7 @@ public static class DependencyInjection
public static IServiceCollection AddApplication(this IServiceCollection services)
{
services.AddScoped();
+ services.AddScoped();
services.AddScoped();
services.AddScoped(provider => provider.GetRequiredService());
services.AddScoped(provider => provider.GetRequiredService());
diff --git a/Tiku.Application/Scoreline/ScorelineModels.cs b/Tiku.Application/Scoreline/ScorelineModels.cs
index a5de053..5e0dd94 100644
--- a/Tiku.Application/Scoreline/ScorelineModels.cs
+++ b/Tiku.Application/Scoreline/ScorelineModels.cs
@@ -51,10 +51,17 @@ public sealed record ScorelineRecordPage(
int Total,
IReadOnlyCollection Items);
+public sealed record ScorelineRecordCursorPage(
+ int PageSize,
+ bool HasMore,
+ string? NextCursor,
+ IReadOnlyCollection Items);
+
public interface IScorelineQueryService
{
Task> GetFieldsAsync(ScorelineFilter filter, CancellationToken cancellationToken = default);
Task GetRecordsAsync(ScorelineFilter filter, CancellationToken cancellationToken = default);
+ Task GetRecordsCursorAsync(ScorelineFilter filter, string? cursor, CancellationToken cancellationToken = default);
Task> GetTrendAsync(ScorelineFilter filter, CancellationToken cancellationToken = default);
Task> GetYearsAsync(ScorelineFilter filter, CancellationToken cancellationToken = default);
}
diff --git a/Tiku.Application/Security/ITenantFeatureCacheInvalidator.cs b/Tiku.Application/Security/ITenantFeatureCacheInvalidator.cs
new file mode 100644
index 0000000..9efc2fb
--- /dev/null
+++ b/Tiku.Application/Security/ITenantFeatureCacheInvalidator.cs
@@ -0,0 +1,6 @@
+namespace Tiku.Application.Security;
+
+public interface ITenantFeatureCacheInvalidator
+{
+ Task InvalidateAsync(Guid tenantId, CancellationToken cancellationToken = default);
+}
diff --git a/Tiku.Application/Tenancy/ITenantPublicCacheInvalidator.cs b/Tiku.Application/Tenancy/ITenantPublicCacheInvalidator.cs
new file mode 100644
index 0000000..f992aaa
--- /dev/null
+++ b/Tiku.Application/Tenancy/ITenantPublicCacheInvalidator.cs
@@ -0,0 +1,6 @@
+namespace Tiku.Application.Tenancy;
+
+public interface ITenantPublicCacheInvalidator
+{
+ Task InvalidateAsync(Guid tenantId, CancellationToken cancellationToken = default);
+}
diff --git a/Tiku.Application/Tenancy/TenantDomainLifecycleModels.cs b/Tiku.Application/Tenancy/TenantDomainLifecycleModels.cs
index 6b49f79..7ac93d1 100644
--- a/Tiku.Application/Tenancy/TenantDomainLifecycleModels.cs
+++ b/Tiku.Application/Tenancy/TenantDomainLifecycleModels.cs
@@ -35,5 +35,5 @@ public interface ITenantDomainLifecycleService
public interface ITenantRuntimeCacheInvalidator
{
- void Invalidate(Guid tenantId);
+ Task InvalidateAsync(Guid tenantId, CancellationToken cancellationToken = default);
}
diff --git a/Tiku.Infrastructure/Auth/AuthSessionStore.cs b/Tiku.Infrastructure/Auth/AuthSessionStore.cs
index a89895f..fde2f65 100644
--- a/Tiku.Infrastructure/Auth/AuthSessionStore.cs
+++ b/Tiku.Infrastructure/Auth/AuthSessionStore.cs
@@ -152,28 +152,43 @@ public sealed class AuthSessionStore(
CancellationToken cancellationToken = default)
{
var now = DateTimeOffset.UtcNow;
- var session = await dbContext.AuthSessions.AsNoTracking().SingleOrDefaultAsync(
- item => item.Id == sessionId && item.UserId == userId && item.Realm == realm &&
- item.TenantId == tenantId && item.RevokedAt == null && item.ExpiresAt > now,
- cancellationToken);
- if (session is null)
- {
- return null;
- }
-
- var user = await dbContext.Users.AsNoTracking().SingleOrDefaultAsync(item => item.Id == userId, cancellationToken);
- if (user is null || user.Status != UserStatus.Active ||
- !string.Equals(user.SecurityStamp, session.SecurityStamp, StringComparison.Ordinal))
- {
- return null;
- }
-
- try
- {
- await AssertRealmAccessAsync(
- realm, tenantId, userId, cancellationToken);
- }
- catch (TenantAccessDeniedException)
+ var state = await (
+ from session in dbContext.AuthSessions.AsNoTracking()
+ join user in dbContext.Users.AsNoTracking() on session.UserId equals user.Id
+ where session.Id == sessionId &&
+ session.UserId == userId &&
+ session.Realm == realm &&
+ session.TenantId == tenantId &&
+ session.RevokedAt == null &&
+ session.ExpiresAt > now
+ select new
+ {
+ UserStatus = user.Status,
+ UserSecurityStamp = user.SecurityStamp,
+ SessionSecurityStamp = session.SecurityStamp,
+ TenantAllowed = realm != AuthRealm.Tenant ||
+ (tenantId != null &&
+ dbContext.Tenants.Any(item => item.Id == tenantId && item.Status == TenantStatus.Active) &&
+ dbContext.TenantMemberships.Any(item =>
+ item.TenantId == tenantId &&
+ item.UserId == userId &&
+ item.Status == MembershipStatus.Active)),
+ PlatformAllowed = realm != AuthRealm.Platform ||
+ (from userRole in dbContext.PlatformBackendUserRoles
+ join role in dbContext.PlatformBackendRoles on userRole.RoleId equals role.Id
+ join binding in dbContext.PlatformBackendRolePermissions on role.Id equals binding.RoleId
+ join permission in dbContext.BackendPermissions on binding.PermissionCode equals permission.Code
+ where userRole.UserId == userId &&
+ role.Status == BackendRoleStatus.Active &&
+ (permission.Area == BackendPermissionArea.Platform || permission.Area == BackendPermissionArea.Both)
+ select permission.Id).Any()
+ })
+ .SingleOrDefaultAsync(cancellationToken);
+ if (state is null ||
+ state.UserStatus != UserStatus.Active ||
+ !string.Equals(state.UserSecurityStamp, state.SessionSecurityStamp, StringComparison.Ordinal) ||
+ !state.TenantAllowed ||
+ !state.PlatformAllowed)
{
return null;
}
diff --git a/Tiku.Infrastructure/DependencyInjection.cs b/Tiku.Infrastructure/DependencyInjection.cs
index c30ab1f..41ac24a 100644
--- a/Tiku.Infrastructure/DependencyInjection.cs
+++ b/Tiku.Infrastructure/DependencyInjection.cs
@@ -49,6 +49,7 @@ using Tiku.Domain.Identity;
using StackExchange.Redis;
using MassTransit;
using Tiku.Infrastructure.Messaging;
+using Tiku.Infrastructure.Observability;
namespace Tiku.Infrastructure;
@@ -63,13 +64,16 @@ public static class DependencyInjection
services.AddSingleton(_ => NpgsqlDataSource.Create(connectionString));
services.AddScoped();
+ services.AddSingleton();
services.AddDbContext((serviceProvider, options) =>
{
var dataSource = serviceProvider.GetRequiredService();
options.UseNpgsql(dataSource, npgsql =>
npgsql.MigrationsAssembly(typeof(TikuDbContext).Assembly.FullName));
configureDatabase?.Invoke(options);
- options.AddInterceptors(serviceProvider.GetRequiredService());
+ options.AddInterceptors(
+ serviceProvider.GetRequiredService(),
+ serviceProvider.GetRequiredService());
});
services.AddIdentityCore(options =>
{
@@ -94,6 +98,7 @@ public static class DependencyInjection
services.AddScoped();
services.AddScoped();
services.AddSingleton();
+ services.AddSingleton();
services.AddHttpClient();
services.AddHttpClient();
services.AddScoped();
@@ -117,6 +122,7 @@ public static class DependencyInjection
services.AddScoped();
services.AddScoped();
services.AddScoped();
+ services.AddScoped();
services.AddScoped();
services.AddScoped();
services.AddScoped();
@@ -141,6 +147,10 @@ public static class DependencyInjection
services.AddOptions();
services.AddScoped();
services.AddScoped();
+ services.AddScoped();
+ services.AddSingleton();
+ services.AddSingleton(provider => provider.GetRequiredService());
+ services.AddHostedService(provider => provider.GetRequiredService());
services.AddScoped();
services.AddScoped();
services.AddOptions();
diff --git a/Tiku.Infrastructure/Jobs/BackgroundJobService.cs b/Tiku.Infrastructure/Jobs/BackgroundJobService.cs
index 1cc1490..0adae11 100644
--- a/Tiku.Infrastructure/Jobs/BackgroundJobService.cs
+++ b/Tiku.Infrastructure/Jobs/BackgroundJobService.cs
@@ -97,20 +97,38 @@ internal sealed class BackgroundJobService(
CancellationToken cancellationToken = default)
{
var now = DateTimeOffset.UtcNow;
- var jobs = await dbContext.BackgroundJobs
- .Where(job =>
- job.Status == BackgroundJobStatus.Pending &&
- (includeImmediateJobs || job.RunAfter != null) &&
- (job.RunAfter == null || job.RunAfter <= now))
- .OrderBy(job => job.CreatedAt)
- .Take(Math.Clamp(batchSize, 1, 100))
+ var leaseExpiresAt = now.Add(LeaseDuration);
+ var claimedIds = await dbContext.Database.SqlQuery($"""
+ UPDATE background_jobs AS job
+ SET status = 'processing',
+ locked_by = {workerId},
+ lock_expires_at = {leaseExpiresAt},
+ started_at = COALESCE(started_at, {now}),
+ updated_at = {now}
+ WHERE job.id IN (
+ SELECT candidate.id
+ FROM background_jobs AS candidate
+ WHERE (
+ (candidate.status = 'pending' AND ({includeImmediateJobs} OR candidate.run_after IS NOT NULL) AND
+ (candidate.run_after IS NULL OR candidate.run_after <= {now})) OR
+ (candidate.status = 'processing' AND candidate.lock_expires_at <= {now})
+ )
+ ORDER BY candidate.created_at, candidate.id
+ FOR UPDATE SKIP LOCKED
+ LIMIT {Math.Clamp(batchSize, 1, 100)}
+ )
+ RETURNING job.id AS "Value"
+ """)
.ToArrayAsync(cancellationToken);
var processed = 0;
- foreach (var job in jobs)
+ dbContext.ChangeTracker.Clear();
+ foreach (var jobId in claimedIds)
{
cancellationToken.ThrowIfCancellationRequested();
- if (await ProcessJobAsync(job, workerId, cancellationToken)) processed++;
+ var job = await dbContext.BackgroundJobs.SingleAsync(value => value.Id == jobId, cancellationToken);
+ if (await ProcessJobAsync(job, workerId, alreadyClaimed: true, cancellationToken)) processed++;
+ dbContext.ChangeTracker.Clear();
}
return processed;
@@ -124,6 +142,21 @@ internal sealed class BackgroundJobService(
CancellationToken cancellationToken = default)
{
var normalizedJobType = NormalizeJobType(jobType);
+ var claimed = await dbContext.BackgroundJobs
+ .Where(item => item.Id == jobId && item.TenantId == tenantId &&
+ item.JobType == normalizedJobType && item.Status == BackgroundJobStatus.Pending &&
+ item.RunAfter == null)
+ .ExecuteUpdateAsync(setters => setters
+ .SetProperty(item => item.Status, BackgroundJobStatus.Processing)
+ .SetProperty(item => item.LockedBy, workerId)
+ .SetProperty(item => item.LockExpiresAt, DateTimeOffset.UtcNow.Add(LeaseDuration))
+ .SetProperty(item => item.StartedAt, DateTimeOffset.UtcNow), cancellationToken);
+ if (claimed == 0)
+ {
+ return false;
+ }
+
+ dbContext.ChangeTracker.Clear();
var job = await dbContext.BackgroundJobs.SingleOrDefaultAsync(
item => item.Id == jobId && item.TenantId == tenantId,
cancellationToken);
@@ -135,20 +168,17 @@ internal sealed class BackgroundJobService(
{
throw new InvalidOperationException("The requested background job type does not match the persisted job.");
}
- if (job.Status != BackgroundJobStatus.Pending || job.RunAfter is not null)
- {
- return false;
- }
-
- return await ProcessJobAsync(job, workerId, cancellationToken);
+ return await ProcessJobAsync(job, workerId, alreadyClaimed: true, cancellationToken);
}
private async Task ProcessJobAsync(
BackgroundJob job,
string workerId,
+ bool alreadyClaimed,
CancellationToken cancellationToken)
{
- if (job.Status != BackgroundJobStatus.Pending)
+ if ((!alreadyClaimed && job.Status != BackgroundJobStatus.Pending) ||
+ (alreadyClaimed && (job.Status != BackgroundJobStatus.Processing || job.LockedBy != workerId)))
{
return false;
}
@@ -158,19 +188,25 @@ internal sealed class BackgroundJobService(
FeatureAccessOperation.Write,
cancellationToken)).Allowed)
{
- job.Status = BackgroundJobStatus.Failed;
- job.CompletedAt = DateTimeOffset.UtcNow;
- job.LastError = "Tenant feature entitlement was revoked before job execution.";
- await dbContext.SaveChangesAsync(cancellationToken);
+ await CompleteAsync(
+ job,
+ workerId,
+ BackgroundJobStatus.Failed,
+ JsonDefaults.Object(),
+ "Tenant feature entitlement was revoked before job execution.",
+ cancellationToken);
return true;
}
- var now = DateTimeOffset.UtcNow;
- job.Status = BackgroundJobStatus.Processing;
- job.LockedBy = workerId;
- job.LockExpiresAt = now.Add(LeaseDuration);
- job.StartedAt = now;
- await dbContext.SaveChangesAsync(cancellationToken);
+ if (!alreadyClaimed)
+ {
+ var now = DateTimeOffset.UtcNow;
+ job.Status = BackgroundJobStatus.Processing;
+ job.LockedBy = workerId;
+ job.LockExpiresAt = now.Add(LeaseDuration);
+ job.StartedAt = now;
+ await dbContext.SaveChangesAsync(cancellationToken);
+ }
try
{
@@ -198,14 +234,35 @@ internal sealed class BackgroundJobService(
}
finally
{
- job.LockedBy = null;
- job.LockExpiresAt = null;
- await dbContext.SaveChangesAsync(cancellationToken);
+ await CompleteAsync(job, workerId, job.Status, job.Result, job.LastError, cancellationToken);
}
return true;
}
+ private async Task CompleteAsync(
+ BackgroundJob job,
+ string workerId,
+ BackgroundJobStatus status,
+ JsonElement result,
+ string? lastError,
+ CancellationToken cancellationToken)
+ {
+ await dbContext.BackgroundJobs
+ .Where(value => value.Id == job.Id && value.LockedBy == workerId)
+ .ExecuteUpdateAsync(setters => setters
+ .SetProperty(value => value.Status, status)
+ .SetProperty(value => value.RetryCount, job.RetryCount)
+ .SetProperty(value => value.RunAfter, job.RunAfter)
+ .SetProperty(value => value.CompletedAt, job.CompletedAt)
+ .SetProperty(value => value.LastError, lastError)
+ .SetProperty(value => value.OutputAssetId, job.OutputAssetId)
+ .SetProperty(value => value.Result, result)
+ .SetProperty(value => value.LockedBy, (string?)null)
+ .SetProperty(value => value.LockExpiresAt, (DateTimeOffset?)null),
+ cancellationToken);
+ }
+
public async Task> ListAsync(
Guid tenantId,
string? jobType = null,
diff --git a/Tiku.Infrastructure/Observability/DatabasePerformanceInterceptor.cs b/Tiku.Infrastructure/Observability/DatabasePerformanceInterceptor.cs
new file mode 100644
index 0000000..0ae5a68
--- /dev/null
+++ b/Tiku.Infrastructure/Observability/DatabasePerformanceInterceptor.cs
@@ -0,0 +1,83 @@
+using System.Data.Common;
+using System.Diagnostics;
+using Microsoft.EntityFrameworkCore.Diagnostics;
+using Microsoft.Extensions.Logging;
+
+namespace Tiku.Infrastructure.Observability;
+
+public sealed class DatabasePerformanceInterceptor(
+ ILogger logger) : DbCommandInterceptor
+{
+ private const double SlowCommandMilliseconds = 500;
+
+ public override DbDataReader ReaderExecuted(
+ DbCommand command,
+ CommandExecutedEventData eventData,
+ DbDataReader result)
+ {
+ Record(command, eventData.Duration, "reader");
+ return result;
+ }
+
+ public override ValueTask ReaderExecutedAsync(
+ DbCommand command,
+ CommandExecutedEventData eventData,
+ DbDataReader result,
+ CancellationToken cancellationToken = default)
+ {
+ Record(command, eventData.Duration, "reader");
+ return ValueTask.FromResult(result);
+ }
+
+ public override int NonQueryExecuted(DbCommand command, CommandExecutedEventData eventData, int result)
+ {
+ Record(command, eventData.Duration, "non_query");
+ return result;
+ }
+
+ public override ValueTask NonQueryExecutedAsync(
+ DbCommand command,
+ CommandExecutedEventData eventData,
+ int result,
+ CancellationToken cancellationToken = default)
+ {
+ Record(command, eventData.Duration, "non_query");
+ return ValueTask.FromResult(result);
+ }
+
+ public override object? ScalarExecuted(DbCommand command, CommandExecutedEventData eventData, object? result)
+ {
+ Record(command, eventData.Duration, "scalar");
+ return result;
+ }
+
+ public override ValueTask ScalarExecutedAsync(
+ DbCommand command,
+ CommandExecutedEventData eventData,
+ object? result,
+ CancellationToken cancellationToken = default)
+ {
+ Record(command, eventData.Duration, "scalar");
+ return ValueTask.FromResult(result);
+ }
+
+ private void Record(DbCommand command, TimeSpan duration, string operation)
+ {
+ var fingerprint = DatabasePerformanceTelemetry.Fingerprint(command.CommandText);
+ var tags = new TagList { { "db.operation", operation } };
+ DatabasePerformanceTelemetry.CommandCounter.Add(1, tags);
+ DatabasePerformanceTelemetry.CommandDuration.Record(
+ duration.TotalMilliseconds,
+ tags);
+ DatabaseRequestMetrics.Record(duration, fingerprint);
+
+ if (duration.TotalMilliseconds >= SlowCommandMilliseconds)
+ {
+ logger.LogWarning(
+ "Slow database command {CommandFingerprint} ({Operation}) completed in {ElapsedMilliseconds:F1} ms.",
+ fingerprint,
+ operation,
+ duration.TotalMilliseconds);
+ }
+ }
+}
diff --git a/Tiku.Infrastructure/Observability/DatabaseRequestMetrics.cs b/Tiku.Infrastructure/Observability/DatabaseRequestMetrics.cs
new file mode 100644
index 0000000..8cc3647
--- /dev/null
+++ b/Tiku.Infrastructure/Observability/DatabaseRequestMetrics.cs
@@ -0,0 +1,106 @@
+using System.Diagnostics;
+using System.Diagnostics.Metrics;
+using System.Security.Cryptography;
+using System.Text;
+
+namespace Tiku.Infrastructure.Observability;
+
+public sealed record DatabaseRequestSnapshot(
+ int CommandCount,
+ double TotalDurationMilliseconds,
+ double SlowestDurationMilliseconds,
+ string? SlowestCommandFingerprint);
+
+public static class DatabasePerformanceTelemetry
+{
+ public const string MeterName = "Tiku.Database";
+
+ internal static readonly Meter Meter = new(MeterName, "1.0.0");
+ internal static readonly Counter CommandCounter = Meter.CreateCounter(
+ "tiku.database.commands",
+ description: "Number of database commands executed.");
+ internal static readonly Histogram CommandDuration = Meter.CreateHistogram(
+ "tiku.database.command.duration",
+ unit: "ms",
+ description: "Database command execution duration.");
+ internal static readonly Histogram RequestCommandCount = Meter.CreateHistogram(
+ "tiku.database.request.commands",
+ description: "Database commands executed during one HTTP request.");
+ internal static readonly Histogram RequestCommandDuration = Meter.CreateHistogram(
+ "tiku.database.request.duration",
+ unit: "ms",
+ description: "Aggregate database command duration during one HTTP request.");
+
+ public static string Fingerprint(string commandText)
+ {
+ var hash = SHA256.HashData(Encoding.UTF8.GetBytes(commandText));
+ return Convert.ToHexString(hash.AsSpan(0, 8)).ToLowerInvariant();
+ }
+}
+
+public static class DatabaseRequestMetrics
+{
+ private static readonly AsyncLocal CurrentState = new();
+
+ public static IDisposable Begin()
+ {
+ var previous = CurrentState.Value;
+ var current = new RequestState();
+ CurrentState.Value = current;
+ return new Scope(previous, current);
+ }
+
+ internal static void Record(TimeSpan duration, string fingerprint)
+ {
+ CurrentState.Value?.Record(duration, fingerprint);
+ }
+
+ private sealed class RequestState
+ {
+ private readonly Stopwatch stopwatch = Stopwatch.StartNew();
+ private int commandCount;
+ private long totalTicks;
+ private long slowestTicks;
+ private string? slowestFingerprint;
+
+ public void Record(TimeSpan duration, string fingerprint)
+ {
+ commandCount++;
+ totalTicks += duration.Ticks;
+ if (duration.Ticks > slowestTicks)
+ {
+ slowestTicks = duration.Ticks;
+ slowestFingerprint = fingerprint;
+ }
+ }
+
+ public DatabaseRequestSnapshot Complete()
+ {
+ stopwatch.Stop();
+ return new DatabaseRequestSnapshot(
+ commandCount,
+ TimeSpan.FromTicks(totalTicks).TotalMilliseconds,
+ TimeSpan.FromTicks(slowestTicks).TotalMilliseconds,
+ slowestFingerprint);
+ }
+ }
+
+ private sealed class Scope(RequestState? previous, RequestState current) : IDisposable
+ {
+ private bool disposed;
+
+ public void Dispose()
+ {
+ if (disposed)
+ {
+ return;
+ }
+
+ disposed = true;
+ var snapshot = current.Complete();
+ DatabasePerformanceTelemetry.RequestCommandCount.Record(snapshot.CommandCount);
+ DatabasePerformanceTelemetry.RequestCommandDuration.Record(snapshot.TotalDurationMilliseconds);
+ CurrentState.Value = previous;
+ }
+ }
+}
diff --git a/Tiku.Infrastructure/Persistence/Configurations/ScorelineConfigurations.cs b/Tiku.Infrastructure/Persistence/Configurations/ScorelineConfigurations.cs
index dd89081..fde54a0 100644
--- a/Tiku.Infrastructure/Persistence/Configurations/ScorelineConfigurations.cs
+++ b/Tiku.Infrastructure/Persistence/Configurations/ScorelineConfigurations.cs
@@ -43,6 +43,8 @@ internal sealed class ScorelineRecordConfiguration : IEntityTypeConfiguration new { entity.TenantId, entity.LegacyId }).IsUnique();
builder.HasIndex(entity => new { entity.TenantId, entity.RegionId, entity.SchoolId, entity.MajorId, entity.Year });
builder.HasIndex(entity => new { entity.TenantId, entity.Year });
+ builder.HasIndex(entity => new { entity.TenantId, entity.Year, entity.SchoolName, entity.MajorName, entity.Id })
+ .IsDescending(false, true, false, false, false);
builder.HasOne()
.WithMany()
diff --git a/Tiku.Infrastructure/Persistence/Migrations/20260729093312_OptimizeScorelineQueries.Designer.cs b/Tiku.Infrastructure/Persistence/Migrations/20260729093312_OptimizeScorelineQueries.Designer.cs
new file mode 100644
index 0000000..2676939
--- /dev/null
+++ b/Tiku.Infrastructure/Persistence/Migrations/20260729093312_OptimizeScorelineQueries.Designer.cs
@@ -0,0 +1,20073 @@
+//
+using System;
+using System.Text.Json;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+using Tiku.Infrastructure.Persistence;
+
+#nullable disable
+
+namespace Tiku.Infrastructure.Persistence.Migrations
+{
+ [DbContext(typeof(TikuDbContext))]
+ [Migration("20260729093312_OptimizeScorelineQueries")]
+ partial class OptimizeScorelineQueries
+ {
+ ///
+ protected override void BuildTargetModel(ModelBuilder modelBuilder)
+ {
+#pragma warning disable 612, 618
+ modelBuilder
+ .HasAnnotation("ProductVersion", "10.0.10")
+ .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+ NpgsqlModelBuilderExtensions.HasPostgresExtension(modelBuilder, "citext");
+ NpgsqlModelBuilderExtensions.HasPostgresExtension(modelBuilder, "ltree");
+ NpgsqlModelBuilderExtensions.HasPostgresExtension(modelBuilder, "pg_trgm");
+ NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+ modelBuilder.Entity("MassTransit.EntityFrameworkCoreIntegration.InboxState", b =>
+ {
+ b.Property("Id")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("bigint")
+ .HasColumnName("id");
+
+ NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property("Id"));
+
+ b.Property("Consumed")
+ .HasColumnType("timestamp with time zone")
+ .HasColumnName("consumed");
+
+ b.Property("ConsumerId")
+ .HasColumnType("uuid")
+ .HasColumnName("consumer_id");
+
+ b.Property("Delivered")
+ .HasColumnType("timestamp with time zone")
+ .HasColumnName("delivered");
+
+ b.Property("ExpirationTime")
+ .HasColumnType("timestamp with time zone")
+ .HasColumnName("expiration_time");
+
+ b.Property("LastSequenceNumber")
+ .HasColumnType("bigint")
+ .HasColumnName("last_sequence_number");
+
+ b.Property("LockId")
+ .HasColumnType("uuid")
+ .HasColumnName("lock_id");
+
+ b.Property("MessageId")
+ .HasColumnType("uuid")
+ .HasColumnName("message_id");
+
+ b.Property("ReceiveCount")
+ .HasColumnType("integer")
+ .HasColumnName("receive_count");
+
+ b.Property("Received")
+ .HasColumnType("timestamp with time zone")
+ .HasColumnName("received");
+
+ b.Property("RowVersion")
+ .IsConcurrencyToken()
+ .ValueGeneratedOnAddOrUpdate()
+ .HasColumnType("bytea")
+ .HasColumnName("row_version");
+
+ b.HasKey("Id")
+ .HasName("pk_inbox_state");
+
+ b.HasAlternateKey("MessageId", "ConsumerId")
+ .HasName("ak_inbox_state_message_id_consumer_id");
+
+ b.HasIndex("Delivered")
+ .HasDatabaseName("ix_inbox_state_delivered");
+
+ b.ToTable("inbox_state", (string)null);
+ });
+
+ modelBuilder.Entity("MassTransit.EntityFrameworkCoreIntegration.OutboxMessage", b =>
+ {
+ b.Property("SequenceNumber")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("bigint")
+ .HasColumnName("sequence_number");
+
+ NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property("SequenceNumber"));
+
+ b.Property("Body")
+ .IsRequired()
+ .HasColumnType("text")
+ .HasColumnName("body");
+
+ b.Property("ContentType")
+ .IsRequired()
+ .HasMaxLength(256)
+ .HasColumnType("character varying(256)")
+ .HasColumnName("content_type");
+
+ b.Property("ConversationId")
+ .HasColumnType("uuid")
+ .HasColumnName("conversation_id");
+
+ b.Property("CorrelationId")
+ .HasColumnType("uuid")
+ .HasColumnName("correlation_id");
+
+ b.Property("DestinationAddress")
+ .HasMaxLength(256)
+ .HasColumnType("character varying(256)")
+ .HasColumnName("destination_address");
+
+ b.Property("EnqueueTime")
+ .HasColumnType("timestamp with time zone")
+ .HasColumnName("enqueue_time");
+
+ b.Property("ExpirationTime")
+ .HasColumnType("timestamp with time zone")
+ .HasColumnName("expiration_time");
+
+ b.Property("FaultAddress")
+ .HasMaxLength(256)
+ .HasColumnType("character varying(256)")
+ .HasColumnName("fault_address");
+
+ b.Property("Headers")
+ .HasColumnType("text")
+ .HasColumnName("headers");
+
+ b.Property("InboxConsumerId")
+ .HasColumnType("uuid")
+ .HasColumnName("inbox_consumer_id");
+
+ b.Property("InboxMessageId")
+ .HasColumnType("uuid")
+ .HasColumnName("inbox_message_id");
+
+ b.Property("InitiatorId")
+ .HasColumnType("uuid")
+ .HasColumnName("initiator_id");
+
+ b.Property("MessageId")
+ .HasColumnType("uuid")
+ .HasColumnName("message_id");
+
+ b.Property("MessageType")
+ .IsRequired()
+ .HasColumnType("text")
+ .HasColumnName("message_type");
+
+ b.Property("OutboxId")
+ .HasColumnType("uuid")
+ .HasColumnName("outbox_id");
+
+ b.Property("Properties")
+ .HasColumnType("text")
+ .HasColumnName("properties");
+
+ b.Property("RequestId")
+ .HasColumnType("uuid")
+ .HasColumnName("request_id");
+
+ b.Property("ResponseAddress")
+ .HasMaxLength(256)
+ .HasColumnType("character varying(256)")
+ .HasColumnName("response_address");
+
+ b.Property("SentTime")
+ .HasColumnType("timestamp with time zone")
+ .HasColumnName("sent_time");
+
+ b.Property("SourceAddress")
+ .HasMaxLength(256)
+ .HasColumnType("character varying(256)")
+ .HasColumnName("source_address");
+
+ b.HasKey("SequenceNumber")
+ .HasName("pk_outbox_message");
+
+ b.HasIndex("EnqueueTime")
+ .HasDatabaseName("ix_outbox_message_enqueue_time");
+
+ b.HasIndex("ExpirationTime")
+ .HasDatabaseName("ix_outbox_message_expiration_time");
+
+ b.HasIndex("OutboxId", "SequenceNumber")
+ .IsUnique()
+ .HasDatabaseName("ix_outbox_message_outbox_id_sequence_number");
+
+ b.HasIndex("InboxMessageId", "InboxConsumerId", "SequenceNumber")
+ .IsUnique()
+ .HasDatabaseName("ix_outbox_message_inbox_message_id_inbox_consumer_id_sequence_~");
+
+ b.ToTable("outbox_message", (string)null);
+ });
+
+ modelBuilder.Entity("MassTransit.EntityFrameworkCoreIntegration.OutboxState", b =>
+ {
+ b.Property("OutboxId")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("uuid")
+ .HasColumnName("outbox_id");
+
+ b.Property("Created")
+ .HasColumnType("timestamp with time zone")
+ .HasColumnName("created");
+
+ b.Property("Delivered")
+ .HasColumnType("timestamp with time zone")
+ .HasColumnName("delivered");
+
+ b.Property("LastSequenceNumber")
+ .HasColumnType("bigint")
+ .HasColumnName("last_sequence_number");
+
+ b.Property("LockId")
+ .HasColumnType("uuid")
+ .HasColumnName("lock_id");
+
+ b.Property("RowVersion")
+ .IsConcurrencyToken()
+ .ValueGeneratedOnAddOrUpdate()
+ .HasColumnType("bytea")
+ .HasColumnName("row_version");
+
+ b.HasKey("OutboxId")
+ .HasName("pk_outbox_state");
+
+ b.HasIndex("Created")
+ .HasDatabaseName("ix_outbox_state_created");
+
+ b.ToTable("outbox_state", (string)null);
+ });
+
+ modelBuilder.Entity("Microsoft.AspNetCore.DataProtection.EntityFrameworkCore.DataProtectionKey", b =>
+ {
+ b.Property("Id")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("integer")
+ .HasColumnName("id");
+
+ NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property("Id"));
+
+ b.Property("FriendlyName")
+ .HasColumnType("text")
+ .HasColumnName("friendly_name");
+
+ b.Property("Xml")
+ .HasColumnType("text")
+ .HasColumnName("xml");
+
+ b.HasKey("Id")
+ .HasName("pk_data_protection_keys");
+
+ b.ToTable("data_protection_keys", (string)null);
+ });
+
+ modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim", b =>
+ {
+ b.Property("Id")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("integer")
+ .HasColumnName("id");
+
+ NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property("Id"));
+
+ b.Property("ClaimType")
+ .HasColumnType("text")
+ .HasColumnName("claim_type");
+
+ b.Property("ClaimValue")
+ .HasColumnType("text")
+ .HasColumnName("claim_value");
+
+ b.Property("UserId")
+ .HasColumnType("uuid")
+ .HasColumnName("user_id");
+
+ b.HasKey("Id")
+ .HasName("pk_user_claims");
+
+ b.HasIndex("UserId")
+ .HasDatabaseName("ix_user_claims_user_id");
+
+ b.ToTable("user_claims", (string)null);
+ });
+
+ modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin", b =>
+ {
+ b.Property("LoginProvider")
+ .HasColumnType("text")
+ .HasColumnName("login_provider");
+
+ b.Property("ProviderKey")
+ .HasColumnType("text")
+ .HasColumnName("provider_key");
+
+ b.Property("ProviderDisplayName")
+ .HasColumnType("text")
+ .HasColumnName("provider_display_name");
+
+ b.Property("UserId")
+ .HasColumnType("uuid")
+ .HasColumnName("user_id");
+
+ b.HasKey("LoginProvider", "ProviderKey")
+ .HasName("pk_user_logins");
+
+ b.HasIndex("UserId")
+ .HasDatabaseName("ix_user_logins_user_id");
+
+ b.ToTable("user_logins", (string)null);
+ });
+
+ modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken", b =>
+ {
+ b.Property("UserId")
+ .HasColumnType("uuid")
+ .HasColumnName("user_id");
+
+ b.Property("LoginProvider")
+ .HasColumnType("text")
+ .HasColumnName("login_provider");
+
+ b.Property("Name")
+ .HasColumnType("text")
+ .HasColumnName("name");
+
+ b.Property("Value")
+ .HasColumnType("text")
+ .HasColumnName("value");
+
+ b.HasKey("UserId", "LoginProvider", "Name")
+ .HasName("pk_user_tokens");
+
+ b.ToTable("user_tokens", (string)null);
+ });
+
+ modelBuilder.Entity("Tiku.Domain.Catalog.Category", b =>
+ {
+ b.Property("Id")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("uuid")
+ .HasColumnName("id")
+ .HasDefaultValueSql("gen_random_uuid()");
+
+ b.Property("CategoryType")
+ .HasMaxLength(32)
+ .HasColumnType("character varying(32)")
+ .HasColumnName("category_type");
+
+ b.Property("CreatedAt")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("timestamp with time zone")
+ .HasColumnName("created_at")
+ .HasDefaultValueSql("now()");
+
+ b.Property("IsActive")
+ .HasColumnType("boolean")
+ .HasColumnName("is_active");
+
+ b.Property("LegacyId")
+ .HasMaxLength(64)
+ .HasColumnType("character varying(64)")
+ .HasColumnName("legacy_id");
+
+ b.Property("Name")
+ .IsRequired()
+ .HasMaxLength(300)
+ .HasColumnType("character varying(300)")
+ .HasColumnName("name");
+
+ b.Property("NodeId")
+ .HasColumnType("uuid")
+ .HasColumnName("node_id");
+
+ b.Property("SortOrder")
+ .HasColumnType("integer")
+ .HasColumnName("sort_order");
+
+ b.Property("SubjectId")
+ .HasColumnType("uuid")
+ .HasColumnName("subject_id");
+
+ b.Property("SvipQuestionLimit")
+ .HasColumnType("integer")
+ .HasColumnName("svip_question_limit");
+
+ b.Property("TenantId")
+ .HasColumnType("uuid")
+ .HasColumnName("tenant_id");
+
+ b.Property("UpdatedAt")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("timestamp with time zone")
+ .HasColumnName("updated_at")
+ .HasDefaultValueSql("now()");
+
+ b.HasKey("Id")
+ .HasName("pk_categories");
+
+ b.HasAlternateKey("TenantId", "Id")
+ .HasName("ak_categories_tenant_id_id");
+
+ b.HasIndex("TenantId", "LegacyId")
+ .IsUnique()
+ .HasDatabaseName("ix_categories_tenant_id_legacy_id");
+
+ b.HasIndex("TenantId", "NodeId")
+ .HasDatabaseName("ix_categories_tenant_id_node_id");
+
+ b.HasIndex("TenantId", "SubjectId")
+ .HasDatabaseName("ix_categories_tenant_id_subject_id");
+
+ b.ToTable("categories", (string)null);
+ });
+
+ modelBuilder.Entity("Tiku.Domain.Catalog.Major", b =>
+ {
+ b.Property("Id")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("uuid")
+ .HasColumnName("id")
+ .HasDefaultValueSql("gen_random_uuid()");
+
+ b.Property("CreatedAt")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("timestamp with time zone")
+ .HasColumnName("created_at")
+ .HasDefaultValueSql("now()");
+
+ b.Property("Description")
+ .HasColumnType("text")
+ .HasColumnName("description");
+
+ b.Property("IsActive")
+ .HasColumnType("boolean")
+ .HasColumnName("is_active");
+
+ b.Property("LegacyId")
+ .HasMaxLength(64)
+ .HasColumnType("character varying(64)")
+ .HasColumnName("legacy_id");
+
+ b.Property("Name")
+ .IsRequired()
+ .HasMaxLength(300)
+ .HasColumnType("character varying(300)")
+ .HasColumnName("name");
+
+ b.Property("RegionId")
+ .HasColumnType("uuid")
+ .HasColumnName("region_id");
+
+ b.Property("SchoolId")
+ .HasColumnType("uuid")
+ .HasColumnName("school_id");
+
+ b.Property("SortOrder")
+ .HasColumnType("integer")
+ .HasColumnName("sort_order");
+
+ b.Property("StudyTips")
+ .HasColumnType("text")
+ .HasColumnName("study_tips");
+
+ b.Property("TenantId")
+ .HasColumnType("uuid")
+ .HasColumnName("tenant_id");
+
+ b.Property("UpdatedAt")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("timestamp with time zone")
+ .HasColumnName("updated_at")
+ .HasDefaultValueSql("now()");
+
+ b.HasKey("Id")
+ .HasName("pk_majors");
+
+ b.HasAlternateKey("TenantId", "Id")
+ .HasName("ak_majors_tenant_id_id");
+
+ b.HasIndex("TenantId", "LegacyId")
+ .IsUnique()
+ .HasDatabaseName("ix_majors_tenant_id_legacy_id");
+
+ b.HasIndex("TenantId", "RegionId")
+ .HasDatabaseName("ix_majors_tenant_id_region_id");
+
+ b.HasIndex("TenantId", "SchoolId")
+ .HasDatabaseName("ix_majors_tenant_id_school_id");
+
+ b.ToTable("majors", (string)null);
+ });
+
+ modelBuilder.Entity("Tiku.Domain.Catalog.ModuleNode", b =>
+ {
+ b.Property("Id")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("uuid")
+ .HasColumnName("id")
+ .HasDefaultValueSql("gen_random_uuid()");
+
+ b.Property("CreatedAt")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("timestamp with time zone")
+ .HasColumnName("created_at")
+ .HasDefaultValueSql("now()");
+
+ b.Property("IsActive")
+ .HasColumnType("boolean")
+ .HasColumnName("is_active");
+
+ b.Property("LegacyId")
+ .HasMaxLength(64)
+ .HasColumnType("character varying(64)")
+ .HasColumnName("legacy_id");
+
+ b.Property("LegacyModuleId")
+ .HasMaxLength(64)
+ .HasColumnType("character varying(64)")
+ .HasColumnName("legacy_module_id");
+
+ b.Property("LegacyParentId")
+ .HasMaxLength(64)
+ .HasColumnType("character varying(64)")
+ .HasColumnName("legacy_parent_id");
+
+ b.Property("Metadata")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("jsonb")
+ .HasColumnName("metadata")
+ .HasDefaultValueSql("'{}'::jsonb");
+
+ b.Property("ModuleId")
+ .HasColumnType("uuid")
+ .HasColumnName("module_id");
+
+ b.Property("Name")
+ .IsRequired()
+ .HasMaxLength(300)
+ .HasColumnType("character varying(300)")
+ .HasColumnName("name");
+
+ b.Property("ParentId")
+ .HasColumnType("uuid")
+ .HasColumnName("parent_id");
+
+ b.Property("Path")
+ .HasMaxLength(1000)
+ .HasColumnType("character varying(1000)")
+ .HasColumnName("path");
+
+ b.Property("RegionId")
+ .HasColumnType("uuid")
+ .HasColumnName("region_id");
+
+ b.Property("SortOrder")
+ .HasColumnType("integer")
+ .HasColumnName("sort_order");
+
+ b.Property("TenantId")
+ .HasColumnType("uuid")
+ .HasColumnName("tenant_id");
+
+ b.Property("Type")
+ .IsRequired()
+ .HasMaxLength(32)
+ .HasColumnType("character varying(32)")
+ .HasColumnName("type");
+
+ b.Property("UpdatedAt")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("timestamp with time zone")
+ .HasColumnName("updated_at")
+ .HasDefaultValueSql("now()");
+
+ b.HasKey("Id")
+ .HasName("pk_module_nodes");
+
+ b.HasAlternateKey("TenantId", "Id")
+ .HasName("ak_module_nodes_tenant_id_id");
+
+ b.HasIndex("TenantId", "LegacyId")
+ .IsUnique()
+ .HasDatabaseName("ix_module_nodes_tenant_id_legacy_id");
+
+ b.HasIndex("TenantId", "ModuleId")
+ .HasDatabaseName("ix_module_nodes_tenant_id_module_id");
+
+ b.HasIndex("TenantId", "ParentId")
+ .HasDatabaseName("ix_module_nodes_tenant_id_parent_id");
+
+ b.HasIndex("TenantId", "RegionId")
+ .HasDatabaseName("ix_module_nodes_tenant_id_region_id");
+
+ b.ToTable("module_nodes", (string)null);
+ });
+
+ modelBuilder.Entity("Tiku.Domain.Catalog.QuestionTaxonomyAssignment", b =>
+ {
+ b.Property("Id")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("uuid")
+ .HasColumnName("id")
+ .HasDefaultValueSql("gen_random_uuid()");
+
+ b.Property("CreatedAt")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("timestamp with time zone")
+ .HasColumnName("created_at")
+ .HasDefaultValueSql("now()");
+
+ b.Property("IsPrimary")
+ .HasColumnType("boolean")
+ .HasColumnName("is_primary");
+
+ b.Property("QuestionId")
+ .HasColumnType("uuid")
+ .HasColumnName("question_id");
+
+ b.Property("TaxonomyNodeId")
+ .HasColumnType("uuid")
+ .HasColumnName("taxonomy_node_id");
+
+ b.Property("TaxonomyOwnerTenantId")
+ .HasColumnType("uuid")
+ .HasColumnName("taxonomy_owner_tenant_id");
+
+ b.Property("TenantId")
+ .HasColumnType("uuid")
+ .HasColumnName("tenant_id");
+
+ b.HasKey("Id")
+ .HasName("pk_question_taxonomy_assignments");
+
+ b.HasAlternateKey("TenantId", "Id")
+ .HasName("ak_question_taxonomy_assignments_tenant_id_id");
+
+ b.HasIndex("TaxonomyOwnerTenantId", "TaxonomyNodeId")
+ .HasDatabaseName("ix_question_taxonomy_assignments_taxonomy_owner_tenant_id_taxo~");
+
+ b.HasIndex("TenantId", "QuestionId", "TaxonomyOwnerTenantId", "TaxonomyNodeId")
+ .IsUnique()
+ .HasDatabaseName("ix_question_taxonomy_assignments_tenant_id_question_id_taxonom~");
+
+ b.ToTable("question_taxonomy_assignments", (string)null);
+ });
+
+ modelBuilder.Entity("Tiku.Domain.Catalog.Region", b =>
+ {
+ b.Property("Id")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("uuid")
+ .HasColumnName("id")
+ .HasDefaultValueSql("gen_random_uuid()");
+
+ b.Property("Code")
+ .HasMaxLength(50)
+ .HasColumnType("character varying(50)")
+ .HasColumnName("code");
+
+ b.Property("Config")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("jsonb")
+ .HasColumnName("config")
+ .HasDefaultValueSql("'{}'::jsonb");
+
+ b.Property("CreatedAt")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("timestamp with time zone")
+ .HasColumnName("created_at")
+ .HasDefaultValueSql("now()");
+
+ b.Property("FullName")
+ .HasMaxLength(300)
+ .HasColumnType("character varying(300)")
+ .HasColumnName("full_name");
+
+ b.Property("Icon")
+ .HasMaxLength(2048)
+ .HasColumnType("character varying(2048)")
+ .HasColumnName("icon");
+
+ b.Property("IsActive")
+ .HasColumnType("boolean")
+ .HasColumnName("is_active");
+
+ b.Property("IsHot")
+ .HasColumnType("boolean")
+ .HasColumnName("is_hot");
+
+ b.Property("LegacyId")
+ .HasMaxLength(64)
+ .HasColumnType("character varying(64)")
+ .HasColumnName("legacy_id");
+
+ b.Property("Name")
+ .IsRequired()
+ .HasMaxLength(200)
+ .HasColumnType("character varying(200)")
+ .HasColumnName("name");
+
+ b.Property("Pinyin")
+ .HasMaxLength(255)
+ .HasColumnType("character varying(255)")
+ .HasColumnName("pinyin");
+
+ b.Property("ShortName")
+ .HasMaxLength(100)
+ .HasColumnType("character varying(100)")
+ .HasColumnName("short_name");
+
+ b.Property("SortOrder")
+ .HasColumnType("integer")
+ .HasColumnName("sort_order");
+
+ b.Property("TenantId")
+ .HasColumnType("uuid")
+ .HasColumnName("tenant_id");
+
+ b.Property("UpdatedAt")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("timestamp with time zone")
+ .HasColumnName("updated_at")
+ .HasDefaultValueSql("now()");
+
+ b.HasKey("Id")
+ .HasName("pk_regions");
+
+ b.HasAlternateKey("TenantId", "Id")
+ .HasName("ak_regions_tenant_id_id");
+
+ b.HasIndex("TenantId", "LegacyId")
+ .IsUnique()
+ .HasDatabaseName("ix_regions_tenant_id_legacy_id");
+
+ b.ToTable("regions", (string)null);
+ });
+
+ modelBuilder.Entity("Tiku.Domain.Catalog.RegionModule", b =>
+ {
+ b.Property("Id")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("uuid")
+ .HasColumnName("id")
+ .HasDefaultValueSql("gen_random_uuid()");
+
+ b.Property("Color")
+ .HasMaxLength(50)
+ .HasColumnType("character varying(50)")
+ .HasColumnName("color");
+
+ b.Property("CreatedAt")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("timestamp with time zone")
+ .HasColumnName("created_at")
+ .HasDefaultValueSql("now()");
+
+ b.Property("Description")
+ .HasColumnType("text")
+ .HasColumnName("description");
+
+ b.Property("Icon")
+ .HasMaxLength(2048)
+ .HasColumnType("character varying(2048)")
+ .HasColumnName("icon");
+
+ b.Property("IsActive")
+ .HasColumnType("boolean")
+ .HasColumnName("is_active");
+
+ b.Property("IsPrimarySchoolModule")
+ .HasColumnType("boolean")
+ .HasColumnName("is_primary_school_module");
+
+ b.Property("LegacyId")
+ .HasMaxLength(64)
+ .HasColumnType("character varying(64)")
+ .HasColumnName("legacy_id");
+
+ b.Property("Name")
+ .IsRequired()
+ .HasMaxLength(200)
+ .HasColumnType("character varying(200)")
+ .HasColumnName("name");
+
+ b.Property("RegionId")
+ .HasColumnType("uuid")
+ .HasColumnName("region_id");
+
+ b.Property("Route")
+ .HasMaxLength(500)
+ .HasColumnType("character varying(500)")
+ .HasColumnName("route");
+
+ b.Property("SortOrder")
+ .HasColumnType("integer")
+ .HasColumnName("sort_order");
+
+ b.Property("TenantId")
+ .HasColumnType("uuid")
+ .HasColumnName("tenant_id");
+
+ b.Property("TextColor")
+ .HasMaxLength(50)
+ .HasColumnType("character varying(50)")
+ .HasColumnName("text_color");
+
+ b.Property("Type")
+ .HasMaxLength(50)
+ .HasColumnType("character varying(50)")
+ .HasColumnName("type");
+
+ b.Property("UpdatedAt")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("timestamp with time zone")
+ .HasColumnName("updated_at")
+ .HasDefaultValueSql("now()");
+
+ b.HasKey("Id")
+ .HasName("pk_region_modules");
+
+ b.HasAlternateKey("TenantId", "Id")
+ .HasName("ak_region_modules_tenant_id_id");
+
+ b.HasIndex("TenantId", "LegacyId")
+ .IsUnique()
+ .HasDatabaseName("ix_region_modules_tenant_id_legacy_id");
+
+ b.HasIndex("TenantId", "RegionId")
+ .HasDatabaseName("ix_region_modules_tenant_id_region_id");
+
+ b.ToTable("region_modules", (string)null);
+ });
+
+ modelBuilder.Entity("Tiku.Domain.Catalog.School", b =>
+ {
+ b.Property("Id")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("uuid")
+ .HasColumnName("id")
+ .HasDefaultValueSql("gen_random_uuid()");
+
+ b.Property("CreatedAt")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("timestamp with time zone")
+ .HasColumnName("created_at")
+ .HasDefaultValueSql("now()");
+
+ b.Property("LegacyId")
+ .HasMaxLength(64)
+ .HasColumnType("character varying(64)")
+ .HasColumnName("legacy_id");
+
+ b.Property("Metadata")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("jsonb")
+ .HasColumnName("metadata")
+ .HasDefaultValueSql("'{}'::jsonb");
+
+ b.Property("ModuleId")
+ .HasColumnType("uuid")
+ .HasColumnName("module_id");
+
+ b.Property("Name")
+ .IsRequired()
+ .HasMaxLength(300)
+ .HasColumnType("character varying(300)")
+ .HasColumnName("name");
+
+ b.Property("ProfessionalExamDate")
+ .HasMaxLength(255)
+ .HasColumnType("character varying(255)")
+ .HasColumnName("professional_exam_date");
+
+ b.Property("RegionId")
+ .HasColumnType("uuid")
+ .HasColumnName("region_id");
+
+ b.Property("TenantId")
+ .HasColumnType("uuid")
+ .HasColumnName("tenant_id");
+
+ b.Property("UpdatedAt")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("timestamp with time zone")
+ .HasColumnName("updated_at")
+ .HasDefaultValueSql("now()");
+
+ b.HasKey("Id")
+ .HasName("pk_schools");
+
+ b.HasAlternateKey("TenantId", "Id")
+ .HasName("ak_schools_tenant_id_id");
+
+ b.HasIndex("TenantId", "LegacyId")
+ .IsUnique()
+ .HasDatabaseName("ix_schools_tenant_id_legacy_id");
+
+ b.HasIndex("TenantId", "ModuleId")
+ .HasDatabaseName("ix_schools_tenant_id_module_id");
+
+ b.HasIndex("TenantId", "RegionId")
+ .HasDatabaseName("ix_schools_tenant_id_region_id");
+
+ b.ToTable("schools", (string)null);
+ });
+
+ modelBuilder.Entity("Tiku.Domain.Catalog.ScorelineField", b =>
+ {
+ b.Property("Id")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("uuid")
+ .HasColumnName("id")
+ .HasDefaultValueSql("gen_random_uuid()");
+
+ b.Property("CreatedAt")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("timestamp with time zone")
+ .HasColumnName("created_at")
+ .HasDefaultValueSql("now()");
+
+ b.Property("Description")
+ .HasMaxLength(1000)
+ .HasColumnType("character varying(1000)")
+ .HasColumnName("description");
+
+ b.Property("FieldKey")
+ .IsRequired()
+ .HasMaxLength(64)
+ .HasColumnType("character varying(64)")
+ .HasColumnName("field_key");
+
+ b.Property("FieldName")
+ .IsRequired()
+ .HasMaxLength(200)
+ .HasColumnType("character varying(200)")
+ .HasColumnName("field_name");
+
+ b.Property("FieldType")
+ .IsRequired()
+ .HasMaxLength(32)
+ .HasColumnType("character varying(32)")
+ .HasColumnName("field_type");
+
+ b.Property("IsFilter")
+ .HasColumnType("boolean")
+ .HasColumnName("is_filter");
+
+ b.Property("IsRequired")
+ .HasColumnType("boolean")
+ .HasColumnName("is_required");
+
+ b.Property