feat: 新增配额包/支付相关实体与迁移

App：新增 operation_logs/quota_packages/tenant_payments/tenant_quota_package_purchases 表 Identity：修正 Avatar 字段类型（varchar(256)->text），保持现有数据不变
2025-12-17 17:27:45 +08:00
parent 9c28790f5e
commit ab59e2e3e2
103 changed files with 14450 additions and 4 deletions
--- a/src/Infrastructure/TakeoutSaaS.Infrastructure/App/Repositories/EfQuotaPackageRepository.cs
+++ b/src/Infrastructure/TakeoutSaaS.Infrastructure/App/Repositories/EfQuotaPackageRepository.cs
@@ -0,0 +1,164 @@
+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 配额包仓储实现。
+/// </summary>
+public sealed class EfQuotaPackageRepository(TakeoutAppDbContext context) : IQuotaPackageRepository
+{
+    #region 配额包定义
+
+    /// <inheritdoc />
+    public Task<QuotaPackage?> FindByIdAsync(long id, CancellationToken cancellationToken = default)
+    {
+        return context.QuotaPackages
+            .FirstOrDefaultAsync(x => x.Id == id && x.DeletedAt == null, cancellationToken);
+    }
+
+    /// <inheritdoc />
+    public async Task<(IReadOnlyList<QuotaPackage> Items, int Total)> SearchPagedAsync(
+        TenantQuotaType? quotaType,
+        bool? isActive,
+        int page,
+        int pageSize,
+        CancellationToken cancellationToken = default)
+    {
+        var query = context.QuotaPackages.AsNoTracking()
+            .Where(x => x.DeletedAt == null);
+
+        if (quotaType.HasValue)
+        {
+            query = query.Where(x => x.QuotaType == quotaType.Value);
+        }
+
+        if (isActive.HasValue)
+        {
+            query = query.Where(x => x.IsActive == isActive.Value);
+        }
+
+        var total = await query.CountAsync(cancellationToken);
+
+        var items = await query
+            .OrderBy(x => x.SortOrder)
+            .ThenBy(x => x.CreatedAt)
+            .Skip((page - 1) * pageSize)
+            .Take(pageSize)
+            .ToListAsync(cancellationToken);
+
+        return (items, total);
+    }
+
+    /// <inheritdoc />
+    public Task AddAsync(QuotaPackage quotaPackage, CancellationToken cancellationToken = default)
+    {
+        return context.QuotaPackages.AddAsync(quotaPackage, cancellationToken).AsTask();
+    }
+
+    /// <inheritdoc />
+    public Task UpdateAsync(QuotaPackage quotaPackage, CancellationToken cancellationToken = default)
+    {
+        context.QuotaPackages.Update(quotaPackage);
+        return Task.CompletedTask;
+    }
+
+    /// <inheritdoc />
+    public async Task<bool> SoftDeleteAsync(long id, CancellationToken cancellationToken = default)
+    {
+        var quotaPackage = await context.QuotaPackages
+            .FirstOrDefaultAsync(x => x.Id == id && x.DeletedAt == null, cancellationToken);
+
+        if (quotaPackage == null)
+        {
+            return false;
+        }
+
+        quotaPackage.DeletedAt = DateTime.UtcNow;
+        return true;
+    }
+
+    #endregion
+
+    #region 配额包购买记录
+
+    /// <inheritdoc />
+    public async Task<(IReadOnlyList<(TenantQuotaPackagePurchase Purchase, QuotaPackage Package)> Items, int Total)> GetPurchasesPagedAsync(
+        long tenantId,
+        int page,
+        int pageSize,
+        CancellationToken cancellationToken = default)
+    {
+        var query = context.TenantQuotaPackagePurchases.AsNoTracking()
+            .Where(x => x.TenantId == tenantId && x.DeletedAt == null);
+
+        var total = await query.CountAsync(cancellationToken);
+
+        var items = await query
+            .OrderByDescending(x => x.PurchasedAt)
+            .Skip((page - 1) * pageSize)
+            .Take(pageSize)
+            .Join(context.QuotaPackages.AsNoTracking(),
+                purchase => purchase.QuotaPackageId,
+                package => package.Id,
+                (purchase, package) => new { Purchase = purchase, Package = package })
+            .ToListAsync(cancellationToken);
+
+        return (items.Select(x => (x.Purchase, x.Package)).ToList(), total);
+    }
+
+    /// <inheritdoc />
+    public Task AddPurchaseAsync(TenantQuotaPackagePurchase purchase, CancellationToken cancellationToken = default)
+    {
+        return context.TenantQuotaPackagePurchases.AddAsync(purchase, cancellationToken).AsTask();
+    }
+
+    #endregion
+
+    #region 配额使用情况
+
+    /// <inheritdoc />
+    public async Task<IReadOnlyList<TenantQuotaUsage>> GetUsageByTenantAsync(
+        long tenantId,
+        TenantQuotaType? quotaType,
+        CancellationToken cancellationToken = default)
+    {
+        var query = context.TenantQuotaUsages.AsNoTracking()
+            .Where(x => x.TenantId == tenantId);
+
+        if (quotaType.HasValue)
+        {
+            query = query.Where(x => x.QuotaType == quotaType.Value);
+        }
+
+        return await query.ToListAsync(cancellationToken);
+    }
+
+    /// <inheritdoc />
+    public Task<TenantQuotaUsage?> FindUsageAsync(
+        long tenantId,
+        TenantQuotaType quotaType,
+        CancellationToken cancellationToken = default)
+    {
+        return context.TenantQuotaUsages
+            .FirstOrDefaultAsync(x => x.TenantId == tenantId && x.QuotaType == quotaType, cancellationToken);
+    }
+
+    /// <inheritdoc />
+    public Task UpdateUsageAsync(TenantQuotaUsage usage, CancellationToken cancellationToken = default)
+    {
+        context.TenantQuotaUsages.Update(usage);
+        return Task.CompletedTask;
+    }
+
+    #endregion
+
+    /// <inheritdoc />
+    public Task SaveChangesAsync(CancellationToken cancellationToken = default)
+    {
+        return context.SaveChangesAsync(cancellationToken);
+    }
+}
--- a/src/Infrastructure/TakeoutSaaS.Infrastructure/App/Repositories/EfStatisticsRepository.cs
+++ b/src/Infrastructure/TakeoutSaaS.Infrastructure/App/Repositories/EfStatisticsRepository.cs
@@ -0,0 +1,116 @@
+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>
+/// 统计数据仓储实现。
+/// </summary>
+public sealed class EfStatisticsRepository(TakeoutAppDbContext dbContext) : IStatisticsRepository
+{
+    #region 订阅统计
+
+    /// <inheritdoc />
+    public async Task<IReadOnlyList<TenantSubscription>> GetAllSubscriptionsAsync(CancellationToken cancellationToken = default)
+    {
+        return await dbContext.TenantSubscriptions
+            .AsNoTracking()
+            .ToListAsync(cancellationToken);
+    }
+
+    /// <inheritdoc />
+    public async Task<IReadOnlyList<ExpiringSubscriptionInfo>> GetExpiringSubscriptionsAsync(
+        int daysAhead,
+        bool onlyWithoutAutoRenew,
+        CancellationToken cancellationToken = default)
+    {
+        var now = DateTime.UtcNow;
+        var targetDate = now.AddDays(daysAhead);
+
+        // 构建基础查询
+        var query = dbContext.TenantSubscriptions
+            .AsNoTracking()
+            .Where(s => s.Status == SubscriptionStatus.Active
+                     && s.EffectiveTo >= now
+                     && s.EffectiveTo <= targetDate);
+
+        // 如果只查询未开启自动续费的
+        if (onlyWithoutAutoRenew)
+        {
+            query = query.Where(s => !s.AutoRenew);
+        }
+
+        // 连接租户和套餐信息
+        var result = await query
+            .Join(
+                dbContext.Tenants,
+                sub => sub.TenantId,
+                tenant => tenant.Id,
+                (sub, tenant) => new { Subscription = sub, Tenant = tenant }
+            )
+            .Join(
+                dbContext.TenantPackages,
+                combined => combined.Subscription.TenantPackageId,
+                package => package.Id,
+                (combined, package) => new ExpiringSubscriptionInfo
+                {
+                    Subscription = combined.Subscription,
+                    TenantName = combined.Tenant.Name,
+                    PackageName = package.Name
+                }
+            )
+            .OrderBy(x => x.Subscription.EffectiveTo)
+            .ToListAsync(cancellationToken);
+
+        return result;
+    }
+
+    #endregion
+
+    #region 收入统计
+
+    /// <inheritdoc />
+    public async Task<IReadOnlyList<TenantBillingStatement>> GetPaidBillsAsync(CancellationToken cancellationToken = default)
+    {
+        return await dbContext.TenantBillingStatements
+            .AsNoTracking()
+            .Where(b => b.Status == TenantBillingStatus.Paid)
+            .ToListAsync(cancellationToken);
+    }
+
+    #endregion
+
+    #region 配额使用排行
+
+    /// <inheritdoc />
+    public async Task<IReadOnlyList<QuotaUsageRankInfo>> GetQuotaUsageRankingAsync(
+        TenantQuotaType quotaType,
+        int topN,
+        CancellationToken cancellationToken = default)
+    {
+        return await dbContext.TenantQuotaUsages
+            .AsNoTracking()
+            .Where(q => q.QuotaType == quotaType && q.LimitValue > 0)
+            .Join(
+                dbContext.Tenants,
+                quota => quota.TenantId,
+                tenant => tenant.Id,
+                (quota, tenant) => new QuotaUsageRankInfo
+                {
+                    TenantId = quota.TenantId,
+                    TenantName = tenant.Name,
+                    UsedValue = quota.UsedValue,
+                    LimitValue = quota.LimitValue,
+                    UsagePercentage = quota.LimitValue > 0 ? (quota.UsedValue / quota.LimitValue * 100) : 0
+                }
+            )
+            .OrderByDescending(x => x.UsagePercentage)
+            .Take(topN)
+            .ToListAsync(cancellationToken);
+    }
+
+    #endregion
+}
--- a/src/Infrastructure/TakeoutSaaS.Infrastructure/App/Repositories/EfSubscriptionRepository.cs
+++ b/src/Infrastructure/TakeoutSaaS.Infrastructure/App/Repositories/EfSubscriptionRepository.cs
@@ -0,0 +1,270 @@
+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>
+/// 订阅管理仓储实现。
+/// </summary>
+public sealed class EfSubscriptionRepository(TakeoutAppDbContext dbContext) : ISubscriptionRepository
+{
+    #region 订阅查询
+
+    /// <inheritdoc />
+    public async Task<TenantSubscription?> FindByIdAsync(long subscriptionId, CancellationToken cancellationToken = default)
+    {
+        return await dbContext.TenantSubscriptions
+            .FirstOrDefaultAsync(s => s.Id == subscriptionId, cancellationToken);
+    }
+
+    /// <inheritdoc />
+    public async Task<IReadOnlyList<TenantSubscription>> FindByIdsAsync(
+        IEnumerable<long> subscriptionIds,
+        CancellationToken cancellationToken = default)
+    {
+        var ids = subscriptionIds.ToList();
+        return await dbContext.TenantSubscriptions
+            .Where(s => ids.Contains(s.Id))
+            .ToListAsync(cancellationToken);
+    }
+
+    /// <inheritdoc />
+    public async Task<(IReadOnlyList<SubscriptionWithRelations> Items, int Total)> SearchPagedAsync(
+        SubscriptionSearchFilter filter,
+        CancellationToken cancellationToken = default)
+    {
+        // 1. 构建基础查询
+        var query = dbContext.TenantSubscriptions
+            .AsNoTracking()
+            .Join(
+                dbContext.Tenants,
+                sub => sub.TenantId,
+                tenant => tenant.Id,
+                (sub, tenant) => new { Subscription = sub, Tenant = tenant }
+            )
+            .Join(
+                dbContext.TenantPackages,
+                combined => combined.Subscription.TenantPackageId,
+                package => package.Id,
+                (combined, package) => new { combined.Subscription, combined.Tenant, Package = package }
+            )
+            .GroupJoin(
+                dbContext.TenantPackages,
+                combined => combined.Subscription.ScheduledPackageId,
+                scheduledPackage => scheduledPackage.Id,
+                (combined, scheduledPackages) => new { combined.Subscription, combined.Tenant, combined.Package, ScheduledPackage = scheduledPackages.FirstOrDefault() }
+            );
+
+        // 2. 应用过滤条件
+        if (filter.Status.HasValue)
+        {
+            query = query.Where(x => x.Subscription.Status == filter.Status.Value);
+        }
+
+        if (filter.TenantPackageId.HasValue)
+        {
+            query = query.Where(x => x.Subscription.TenantPackageId == filter.TenantPackageId.Value);
+        }
+
+        if (filter.TenantId.HasValue)
+        {
+            query = query.Where(x => x.Subscription.TenantId == filter.TenantId.Value);
+        }
+
+        if (!string.IsNullOrWhiteSpace(filter.TenantKeyword))
+        {
+            var keyword = filter.TenantKeyword.Trim().ToLower();
+            query = query.Where(x => x.Tenant.Name.ToLower().Contains(keyword) || x.Tenant.Code.ToLower().Contains(keyword));
+        }
+
+        if (filter.ExpiringWithinDays.HasValue)
+        {
+            var expiryDate = DateTime.UtcNow.AddDays(filter.ExpiringWithinDays.Value);
+            query = query.Where(x => x.Subscription.EffectiveTo <= expiryDate && x.Subscription.EffectiveTo >= DateTime.UtcNow);
+        }
+
+        if (filter.AutoRenew.HasValue)
+        {
+            query = query.Where(x => x.Subscription.AutoRenew == filter.AutoRenew.Value);
+        }
+
+        // 3. 获取总数
+        var total = await query.CountAsync(cancellationToken);
+
+        // 4. 排序和分页
+        var items = await query
+            .OrderByDescending(x => x.Subscription.CreatedAt)
+            .Skip((filter.Page - 1) * filter.PageSize)
+            .Take(filter.PageSize)
+            .Select(x => new SubscriptionWithRelations
+            {
+                Subscription = x.Subscription,
+                TenantName = x.Tenant.Name,
+                TenantCode = x.Tenant.Code,
+                PackageName = x.Package.Name,
+                ScheduledPackageName = x.ScheduledPackage != null ? x.ScheduledPackage.Name : null
+            })
+            .ToListAsync(cancellationToken);
+
+        return (items, total);
+    }
+
+    /// <inheritdoc />
+    public async Task<SubscriptionDetailInfo?> GetDetailAsync(long subscriptionId, CancellationToken cancellationToken = default)
+    {
+        var result = await dbContext.TenantSubscriptions
+            .AsNoTracking()
+            .Where(s => s.Id == subscriptionId)
+            .Select(s => new
+            {
+                Subscription = s,
+                Tenant = dbContext.Tenants.FirstOrDefault(t => t.Id == s.TenantId),
+                Package = dbContext.TenantPackages.FirstOrDefault(p => p.Id == s.TenantPackageId),
+                ScheduledPackage = s.ScheduledPackageId.HasValue
+                    ? dbContext.TenantPackages.FirstOrDefault(p => p.Id == s.ScheduledPackageId)
+                    : null
+            })
+            .FirstOrDefaultAsync(cancellationToken);
+
+        if (result == null)
+        {
+            return null;
+        }
+
+        return new SubscriptionDetailInfo
+        {
+            Subscription = result.Subscription,
+            TenantName = result.Tenant?.Name ?? "",
+            TenantCode = result.Tenant?.Code ?? "",
+            Package = result.Package,
+            ScheduledPackage = result.ScheduledPackage
+        };
+    }
+
+    /// <inheritdoc />
+    public async Task<IReadOnlyList<SubscriptionWithTenant>> FindByIdsWithTenantAsync(
+        IEnumerable<long> subscriptionIds,
+        CancellationToken cancellationToken = default)
+    {
+        var ids = subscriptionIds.ToList();
+        return await dbContext.TenantSubscriptions
+            .Where(s => ids.Contains(s.Id))
+            .Join(
+                dbContext.Tenants,
+                sub => sub.TenantId,
+                tenant => tenant.Id,
+                (sub, tenant) => new SubscriptionWithTenant
+                {
+                    Subscription = sub,
+                    Tenant = tenant
+                }
+            )
+            .ToListAsync(cancellationToken);
+    }
+
+    #endregion
+
+    #region 套餐查询
+
+    /// <inheritdoc />
+    public async Task<TenantPackage?> FindPackageByIdAsync(long packageId, CancellationToken cancellationToken = default)
+    {
+        return await dbContext.TenantPackages
+            .AsNoTracking()
+            .FirstOrDefaultAsync(p => p.Id == packageId, cancellationToken);
+    }
+
+    #endregion
+
+    #region 订阅更新
+
+    /// <inheritdoc />
+    public Task UpdateAsync(TenantSubscription subscription, CancellationToken cancellationToken = default)
+    {
+        dbContext.TenantSubscriptions.Update(subscription);
+        return Task.CompletedTask;
+    }
+
+    #endregion
+
+    #region 订阅历史
+
+    /// <inheritdoc />
+    public Task AddHistoryAsync(TenantSubscriptionHistory history, CancellationToken cancellationToken = default)
+    {
+        dbContext.TenantSubscriptionHistories.Add(history);
+        return Task.CompletedTask;
+    }
+
+    /// <inheritdoc />
+    public async Task<IReadOnlyList<SubscriptionHistoryWithPackageNames>> GetHistoryAsync(
+        long subscriptionId,
+        CancellationToken cancellationToken = default)
+    {
+        return await dbContext.TenantSubscriptionHistories
+            .AsNoTracking()
+            .Where(h => h.TenantSubscriptionId == subscriptionId)
+            .OrderByDescending(h => h.CreatedAt)
+            .Select(h => new SubscriptionHistoryWithPackageNames
+            {
+                History = h,
+                FromPackageName = dbContext.TenantPackages
+                    .Where(p => p.Id == h.FromPackageId)
+                    .Select(p => p.Name)
+                    .FirstOrDefault() ?? "",
+                ToPackageName = dbContext.TenantPackages
+                    .Where(p => p.Id == h.ToPackageId)
+                    .Select(p => p.Name)
+                    .FirstOrDefault() ?? ""
+            })
+            .ToListAsync(cancellationToken);
+    }
+
+    #endregion
+
+    #region 配额使用
+
+    /// <inheritdoc />
+    public async Task<IReadOnlyList<TenantQuotaUsage>> GetQuotaUsagesAsync(
+        long tenantId,
+        CancellationToken cancellationToken = default)
+    {
+        return await dbContext.TenantQuotaUsages
+            .AsNoTracking()
+            .Where(q => q.TenantId == tenantId)
+            .ToListAsync(cancellationToken);
+    }
+
+    #endregion
+
+    #region 通知
+
+    /// <inheritdoc />
+    public Task AddNotificationAsync(TenantNotification notification, CancellationToken cancellationToken = default)
+    {
+        dbContext.TenantNotifications.Add(notification);
+        return Task.CompletedTask;
+    }
+
+    #endregion
+
+    #region 操作日志
+
+    /// <inheritdoc />
+    public Task AddOperationLogAsync(OperationLog log, CancellationToken cancellationToken = default)
+    {
+        dbContext.Set<OperationLog>().Add(log);
+        return Task.CompletedTask;
+    }
+
+    #endregion
+
+    /// <inheritdoc />
+    public async Task SaveChangesAsync(CancellationToken cancellationToken = default)
+    {
+        await dbContext.SaveChangesAsync(cancellationToken);
+    }
+}
--- a/src/Infrastructure/TakeoutSaaS.Infrastructure/App/Repositories/EfTenantBillingRepository.cs
+++ b/src/Infrastructure/TakeoutSaaS.Infrastructure/App/Repositories/EfTenantBillingRepository.cs
@@ -43,6 +43,69 @@ public sealed class EfTenantBillingRepository(TakeoutAppDbContext context) : ITe
            .ContinueWith(t => (IReadOnlyList<TenantBillingStatement>)t.Result, cancellationToken);
    }

+    /// <inheritdoc />
+    public async Task<(IReadOnlyList<TenantBillingStatement> Items, int Total)> SearchPagedAsync(
+        long? tenantId,
+        TenantBillingStatus? status,
+        DateTime? from,
+        DateTime? to,
+        string? keyword,
+        int pageNumber,
+        int pageSize,
+        CancellationToken cancellationToken = default)
+    {
+        var query = context.TenantBillingStatements.AsNoTracking();
+
+        // 1. 按租户过滤（可选）
+        if (tenantId.HasValue)
+        {
+            query = query.Where(x => x.TenantId == tenantId.Value);
+        }
+
+        // 2. 按状态过滤
+        if (status.HasValue)
+        {
+            query = query.Where(x => x.Status == status.Value);
+        }
+
+        // 3. 按日期范围过滤
+        if (from.HasValue)
+        {
+            query = query.Where(x => x.PeriodStart >= from.Value);
+        }
+
+        if (to.HasValue)
+        {
+            query = query.Where(x => x.PeriodEnd <= to.Value);
+        }
+
+        // 4. 按关键字过滤（账单编号）
+        if (!string.IsNullOrWhiteSpace(keyword))
+        {
+            var normalizedKeyword = keyword.Trim();
+            query = query.Where(x => EF.Functions.ILike(x.StatementNo, $"%{normalizedKeyword}%"));
+        }
+
+        // 5. 统计总数
+        var total = await query.CountAsync(cancellationToken);
+
+        // 6. 分页查询
+        var items = await query
+            .OrderByDescending(x => x.PeriodEnd)
+            .Skip((pageNumber - 1) * pageSize)
+            .Take(pageSize)
+            .ToListAsync(cancellationToken);
+
+        return (items, total);
+    }
+
+    /// <inheritdoc />
+    public Task<TenantBillingStatement?> FindByIdAsync(long billingId, CancellationToken cancellationToken = default)
+    {
+        return context.TenantBillingStatements.AsNoTracking()
+            .FirstOrDefaultAsync(x => x.Id == billingId, cancellationToken);
+    }
+
    /// <inheritdoc />
    public Task<TenantBillingStatement?> FindByIdAsync(long tenantId, long billingId, CancellationToken cancellationToken = default)
    {
--- a/src/Infrastructure/TakeoutSaaS.Infrastructure/App/Repositories/EfTenantPaymentRepository.cs
+++ b/src/Infrastructure/TakeoutSaaS.Infrastructure/App/Repositories/EfTenantPaymentRepository.cs
@@ -0,0 +1,47 @@
+using Microsoft.EntityFrameworkCore;
+using TakeoutSaaS.Domain.Tenants.Entities;
+using TakeoutSaaS.Domain.Tenants.Repositories;
+using TakeoutSaaS.Infrastructure.App.Persistence;
+
+namespace TakeoutSaaS.Infrastructure.App.Repositories;
+
+/// <summary>
+/// EF 租户支付记录仓储。
+/// </summary>
+public sealed class EfTenantPaymentRepository(TakeoutAppDbContext context) : ITenantPaymentRepository
+{
+    /// <inheritdoc />
+    public async Task<IReadOnlyList<TenantPayment>> GetByBillingIdAsync(long billingStatementId, CancellationToken cancellationToken = default)
+    {
+        return await context.TenantPayments.AsNoTracking()
+            .Where(x => x.BillingStatementId == billingStatementId)
+            .OrderByDescending(x => x.PaidAt)
+            .ToListAsync(cancellationToken);
+    }
+
+    /// <inheritdoc />
+    public Task<TenantPayment?> FindByIdAsync(long paymentId, CancellationToken cancellationToken = default)
+    {
+        return context.TenantPayments.AsNoTracking()
+            .FirstOrDefaultAsync(x => x.Id == paymentId, cancellationToken);
+    }
+
+    /// <inheritdoc />
+    public Task AddAsync(TenantPayment payment, CancellationToken cancellationToken = default)
+    {
+        return context.TenantPayments.AddAsync(payment, cancellationToken).AsTask();
+    }
+
+    /// <inheritdoc />
+    public Task UpdateAsync(TenantPayment payment, CancellationToken cancellationToken = default)
+    {
+        context.TenantPayments.Update(payment);
+        return Task.CompletedTask;
+    }
+
+    /// <inheritdoc />
+    public Task SaveChangesAsync(CancellationToken cancellationToken = default)
+    {
+        return context.SaveChangesAsync(cancellationToken);
+    }
+}
--- a/src/Infrastructure/TakeoutSaaS.Infrastructure/App/Repositories/EfTenantRepository.cs
+++ b/src/Infrastructure/TakeoutSaaS.Infrastructure/App/Repositories/EfTenantRepository.cs
@@ -20,6 +20,20 @@ public sealed class EfTenantRepository(TakeoutAppDbContext context) : ITenantRep
            .FirstOrDefaultAsync(x => x.Id == tenantId, cancellationToken);
    }

+    /// <inheritdoc />
+    public async Task<IReadOnlyList<Tenant>> FindByIdsAsync(IReadOnlyCollection<long> tenantIds, CancellationToken cancellationToken = default)
+    {
+        if (tenantIds.Count == 0)
+        {
+            return Array.Empty<Tenant>();
+        }
+
+        return await context.Tenants
+            .AsNoTracking()
+            .Where(x => tenantIds.Contains(x.Id))
+            .ToListAsync(cancellationToken);
+    }
+
    /// <inheritdoc />
    public async Task<IReadOnlyList<Tenant>> SearchAsync(
        TenantStatus? status,