feat: 实现租户管理及套餐流程

2025-12-03 16:37:50 +08:00
parent 151f64d41a
commit a536a554c2
34 changed files with 1732 additions and 2 deletions
--- a/src/Infrastructure/TakeoutSaaS.Infrastructure/App/Extensions/AppServiceCollectionExtensions.cs
+++ b/src/Infrastructure/TakeoutSaaS.Infrastructure/App/Extensions/AppServiceCollectionExtensions.cs
@@ -6,6 +6,7 @@ using TakeoutSaaS.Domain.Orders.Repositories;
 using TakeoutSaaS.Domain.Payments.Repositories;
 using TakeoutSaaS.Domain.Products.Repositories;
 using TakeoutSaaS.Domain.Stores.Repositories;
+using TakeoutSaaS.Domain.Tenants.Repositories;
 using TakeoutSaaS.Infrastructure.App.Options;
 using TakeoutSaaS.Infrastructure.App.Persistence;
 using TakeoutSaaS.Infrastructure.App.Repositories;
@@ -36,6 +37,7 @@ public static class AppServiceCollectionExtensions
        services.AddScoped<IOrderRepository, EfOrderRepository>();
        services.AddScoped<IPaymentRepository, EfPaymentRepository>();
        services.AddScoped<IDeliveryRepository, EfDeliveryRepository>();
+        services.AddScoped<ITenantRepository, EfTenantRepository>();

        services.AddOptions<AppSeedOptions>()
            .Bind(configuration.GetSection(AppSeedOptions.SectionName))
--- a/src/Infrastructure/TakeoutSaaS.Infrastructure/App/Persistence/TakeoutAppDbContext.cs
+++ b/src/Infrastructure/TakeoutSaaS.Infrastructure/App/Persistence/TakeoutAppDbContext.cs
@@ -39,9 +39,12 @@ public sealed class TakeoutAppDbContext(
    public DbSet<Tenant> Tenants => Set<Tenant>();
    public DbSet<TenantPackage> TenantPackages => Set<TenantPackage>();
    public DbSet<TenantSubscription> TenantSubscriptions => Set<TenantSubscription>();
+    public DbSet<TenantSubscriptionHistory> TenantSubscriptionHistories => Set<TenantSubscriptionHistory>();
    public DbSet<TenantQuotaUsage> TenantQuotaUsages => Set<TenantQuotaUsage>();
    public DbSet<TenantBillingStatement> TenantBillingStatements => Set<TenantBillingStatement>();
    public DbSet<TenantNotification> TenantNotifications => Set<TenantNotification>();
+    public DbSet<TenantVerificationProfile> TenantVerificationProfiles => Set<TenantVerificationProfile>();
+    public DbSet<TenantAuditLog> TenantAuditLogs => Set<TenantAuditLog>();

    public DbSet<Merchant> Merchants => Set<Merchant>();
    public DbSet<MerchantDocument> MerchantDocuments => Set<MerchantDocument>();
@@ -132,9 +135,12 @@ public sealed class TakeoutAppDbContext(
        ConfigureStore(modelBuilder.Entity<Store>());
        ConfigureTenantPackage(modelBuilder.Entity<TenantPackage>());
        ConfigureTenantSubscription(modelBuilder.Entity<TenantSubscription>());
+        ConfigureTenantSubscriptionHistory(modelBuilder.Entity<TenantSubscriptionHistory>());
        ConfigureTenantQuotaUsage(modelBuilder.Entity<TenantQuotaUsage>());
        ConfigureTenantBilling(modelBuilder.Entity<TenantBillingStatement>());
        ConfigureTenantNotification(modelBuilder.Entity<TenantNotification>());
+        ConfigureTenantVerificationProfile(modelBuilder.Entity<TenantVerificationProfile>());
+        ConfigureTenantAuditLog(modelBuilder.Entity<TenantAuditLog>());
        ConfigureMerchantDocument(modelBuilder.Entity<MerchantDocument>());
        ConfigureMerchantContract(modelBuilder.Entity<MerchantContract>());
        ConfigureMerchantStaff(modelBuilder.Entity<MerchantStaff>());
@@ -216,6 +222,47 @@ public sealed class TakeoutAppDbContext(
        builder.HasIndex(x => x.Code).IsUnique();
    }

+    private static void ConfigureTenantVerificationProfile(EntityTypeBuilder<TenantVerificationProfile> builder)
+    {
+        builder.ToTable("tenant_verification_profiles");
+        builder.HasKey(x => x.Id);
+        builder.Property(x => x.TenantId).IsRequired();
+        builder.Property(x => x.BusinessLicenseNumber).HasMaxLength(64);
+        builder.Property(x => x.BusinessLicenseUrl).HasMaxLength(512);
+        builder.Property(x => x.LegalPersonName).HasMaxLength(64);
+        builder.Property(x => x.LegalPersonIdNumber).HasMaxLength(32);
+        builder.Property(x => x.LegalPersonIdFrontUrl).HasMaxLength(512);
+        builder.Property(x => x.LegalPersonIdBackUrl).HasMaxLength(512);
+        builder.Property(x => x.BankAccountName).HasMaxLength(128);
+        builder.Property(x => x.BankAccountNumber).HasMaxLength(64);
+        builder.Property(x => x.BankName).HasMaxLength(128);
+        builder.Property(x => x.ReviewRemarks).HasMaxLength(512);
+        builder.Property(x => x.ReviewedByName).HasMaxLength(64);
+        builder.HasIndex(x => x.TenantId).IsUnique();
+    }
+
+    private static void ConfigureTenantAuditLog(EntityTypeBuilder<TenantAuditLog> builder)
+    {
+        builder.ToTable("tenant_audit_logs");
+        builder.HasKey(x => x.Id);
+        builder.Property(x => x.TenantId).IsRequired();
+        builder.Property(x => x.Title).HasMaxLength(128).IsRequired();
+        builder.Property(x => x.Description).HasMaxLength(1024);
+        builder.Property(x => x.OperatorName).HasMaxLength(64);
+        builder.HasIndex(x => x.TenantId);
+    }
+
+    private static void ConfigureTenantSubscriptionHistory(EntityTypeBuilder<TenantSubscriptionHistory> builder)
+    {
+        builder.ToTable("tenant_subscription_histories");
+        builder.HasKey(x => x.Id);
+        builder.Property(x => x.TenantId).IsRequired();
+        builder.Property(x => x.TenantSubscriptionId).IsRequired();
+        builder.Property(x => x.Notes).HasMaxLength(512);
+        builder.Property(x => x.Currency).HasMaxLength(8);
+        builder.HasIndex(x => new { x.TenantId, x.TenantSubscriptionId });
+    }
+
    private static void ConfigureMerchant(EntityTypeBuilder<Merchant> builder)
    {
        builder.ToTable("merchants");
--- a/src/Infrastructure/TakeoutSaaS.Infrastructure/App/Repositories/EfTenantRepository.cs
+++ b/src/Infrastructure/TakeoutSaaS.Infrastructure/App/Repositories/EfTenantRepository.cs
@@ -0,0 +1,161 @@
+using System.Linq;
+using Microsoft.EntityFrameworkCore;
+using TakeoutSaaS.Domain.Tenants.Entities;
+using TakeoutSaaS.Domain.Tenants.Enums;
+using TakeoutSaaS.Domain.Tenants.Repositories;
+using TakeoutSaaS.Infrastructure.App.Persistence;
+
+namespace TakeoutSaaS.Infrastructure.App.Repositories;
+
+/// <summary>
+/// 租户聚合的 EF Core 仓储实现。
+/// </summary>
+public sealed class EfTenantRepository(TakeoutAppDbContext context) : ITenantRepository
+{
+    /// <inheritdoc />
+    public Task<Tenant?> FindByIdAsync(long tenantId, CancellationToken cancellationToken = default)
+    {
+        return context.Tenants
+            .AsNoTracking()
+            .FirstOrDefaultAsync(x => x.Id == tenantId, cancellationToken);
+    }
+
+    /// <inheritdoc />
+    public async Task<IReadOnlyList<Tenant>> SearchAsync(
+        TenantStatus? status,
+        string? keyword,
+        CancellationToken cancellationToken = default)
+    {
+        var query = context.Tenants.AsNoTracking();
+
+        if (status.HasValue)
+        {
+            query = query.Where(x => x.Status == status.Value);
+        }
+
+        if (!string.IsNullOrWhiteSpace(keyword))
+        {
+            keyword = keyword.Trim();
+            query = query.Where(x =>
+                EF.Functions.ILike(x.Name, $"%{keyword}%") ||
+                EF.Functions.ILike(x.Code, $"%{keyword}%") ||
+                EF.Functions.ILike(x.ContactName ?? string.Empty, $"%{keyword}%"));
+        }
+
+        return await query
+            .OrderByDescending(x => x.CreatedAt)
+            .ToListAsync(cancellationToken);
+    }
+
+    /// <inheritdoc />
+    public Task AddTenantAsync(Tenant tenant, CancellationToken cancellationToken = default)
+    {
+        return context.Tenants.AddAsync(tenant, cancellationToken).AsTask();
+    }
+
+    /// <inheritdoc />
+    public Task UpdateTenantAsync(Tenant tenant, CancellationToken cancellationToken = default)
+    {
+        context.Tenants.Update(tenant);
+        return Task.CompletedTask;
+    }
+
+    /// <inheritdoc />
+    public Task<bool> ExistsByCodeAsync(string code, CancellationToken cancellationToken = default)
+    {
+        var normalized = code.Trim();
+        return context.Tenants.AnyAsync(x => x.Code == normalized, cancellationToken);
+    }
+
+    /// <inheritdoc />
+    public Task<TenantVerificationProfile?> GetVerificationProfileAsync(long tenantId, CancellationToken cancellationToken = default)
+    {
+        return context.TenantVerificationProfiles
+            .AsNoTracking()
+            .FirstOrDefaultAsync(x => x.TenantId == tenantId, cancellationToken);
+    }
+
+    /// <inheritdoc />
+    public async Task UpsertVerificationProfileAsync(TenantVerificationProfile profile, CancellationToken cancellationToken = default)
+    {
+        var existing = await context.TenantVerificationProfiles
+            .FirstOrDefaultAsync(x => x.TenantId == profile.TenantId, cancellationToken);
+
+        if (existing == null)
+        {
+            await context.TenantVerificationProfiles.AddAsync(profile, cancellationToken);
+            return;
+        }
+
+        profile.Id = existing.Id;
+        context.Entry(existing).CurrentValues.SetValues(profile);
+    }
+
+    /// <inheritdoc />
+    public Task<TenantSubscription?> GetActiveSubscriptionAsync(long tenantId, CancellationToken cancellationToken = default)
+    {
+        return context.TenantSubscriptions
+            .AsNoTracking()
+            .Where(x => x.TenantId == tenantId)
+            .OrderByDescending(x => x.EffectiveTo)
+            .FirstOrDefaultAsync(cancellationToken);
+    }
+
+    /// <inheritdoc />
+    public Task<TenantSubscription?> FindSubscriptionByIdAsync(long tenantId, long subscriptionId, CancellationToken cancellationToken = default)
+    {
+        return context.TenantSubscriptions
+            .FirstOrDefaultAsync(x => x.TenantId == tenantId && x.Id == subscriptionId, cancellationToken);
+    }
+
+    /// <inheritdoc />
+    public Task AddSubscriptionAsync(TenantSubscription subscription, CancellationToken cancellationToken = default)
+    {
+        return context.TenantSubscriptions.AddAsync(subscription, cancellationToken).AsTask();
+    }
+
+    /// <inheritdoc />
+    public Task UpdateSubscriptionAsync(TenantSubscription subscription, CancellationToken cancellationToken = default)
+    {
+        context.TenantSubscriptions.Update(subscription);
+        return Task.CompletedTask;
+    }
+
+    /// <inheritdoc />
+    public Task AddSubscriptionHistoryAsync(TenantSubscriptionHistory history, CancellationToken cancellationToken = default)
+    {
+        return context.TenantSubscriptionHistories.AddAsync(history, cancellationToken).AsTask();
+    }
+
+    /// <inheritdoc />
+    public async Task<IReadOnlyList<TenantSubscriptionHistory>> GetSubscriptionHistoryAsync(long tenantId, CancellationToken cancellationToken = default)
+    {
+        return await context.TenantSubscriptionHistories
+            .AsNoTracking()
+            .Where(x => x.TenantId == tenantId)
+            .OrderByDescending(x => x.EffectiveFrom)
+            .ToListAsync(cancellationToken);
+    }
+
+    /// <inheritdoc />
+    public Task AddAuditLogAsync(TenantAuditLog log, CancellationToken cancellationToken = default)
+    {
+        return context.TenantAuditLogs.AddAsync(log, cancellationToken).AsTask();
+    }
+
+    /// <inheritdoc />
+    public async Task<IReadOnlyList<TenantAuditLog>> GetAuditLogsAsync(long tenantId, CancellationToken cancellationToken = default)
+    {
+        return await context.TenantAuditLogs
+            .AsNoTracking()
+            .Where(x => x.TenantId == tenantId)
+            .OrderByDescending(x => x.CreatedAt)
+            .ToListAsync(cancellationToken);
+    }
+
+    /// <inheritdoc />
+    public Task SaveChangesAsync(CancellationToken cancellationToken = default)
+    {
+        return context.SaveChangesAsync(cancellationToken);
+    }
+}