feat: 增强仓储CRUD与种子配置

src/Infrastructure/TakeoutSaaS.Infrastructure/App/Repositories/EfDeliveryRepository.cs

@@ -68,4 +68,35 @@ public sealed class EfDeliveryRepository : IDeliveryRepository
     {
         return _context.SaveChangesAsync(cancellationToken);
     }
+
+    /// <inheritdoc />
+    public Task UpdateDeliveryOrderAsync(DeliveryOrder deliveryOrder, CancellationToken cancellationToken = default)
+    {
+        _context.DeliveryOrders.Update(deliveryOrder);
+        return Task.CompletedTask;
+    }
+
+    /// <inheritdoc />
+    public async Task DeleteDeliveryOrderAsync(long deliveryOrderId, long tenantId, CancellationToken cancellationToken = default)
+    {
+        var events = await _context.DeliveryEvents
+            .Where(x => x.TenantId == tenantId && x.DeliveryOrderId == deliveryOrderId)
+            .ToListAsync(cancellationToken);
+
+        if (events.Count > 0)
+        {
+            _context.DeliveryEvents.RemoveRange(events);
+        }
+
+        var existing = await _context.DeliveryOrders
+            .Where(x => x.TenantId == tenantId && x.Id == deliveryOrderId)
+            .FirstOrDefaultAsync(cancellationToken);
+
+        if (existing == null)
+        {
+            return;
+        }
+
+        _context.DeliveryOrders.Remove(existing);
+    }
 }

src/Infrastructure/TakeoutSaaS.Infrastructure/App/Repositories/EfMerchantRepository.cs

@@ -113,4 +113,26 @@ public sealed class EfMerchantRepository : IMerchantRepository
     {
         return _context.SaveChangesAsync(cancellationToken);
     }
+
+    /// <inheritdoc />
+    public Task UpdateMerchantAsync(Merchant merchant, CancellationToken cancellationToken = default)
+    {
+        _context.Merchants.Update(merchant);
+        return Task.CompletedTask;
+    }
+
+    /// <inheritdoc />
+    public async Task DeleteMerchantAsync(long merchantId, long tenantId, CancellationToken cancellationToken = default)
+    {
+        var existing = await _context.Merchants
+            .Where(x => x.TenantId == tenantId && x.Id == merchantId)
+            .FirstOrDefaultAsync(cancellationToken);
+
+        if (existing == null)
+        {
+            return;
+        }
+
+        _context.Merchants.Remove(existing);
+    }
 }

src/Infrastructure/TakeoutSaaS.Infrastructure/App/Repositories/EfOrderRepository.cs

@@ -130,4 +130,49 @@ public sealed class EfOrderRepository : IOrderRepository
     {
         return _context.SaveChangesAsync(cancellationToken);
     }
+
+    /// <inheritdoc />
+    public Task UpdateOrderAsync(Order order, CancellationToken cancellationToken = default)
+    {
+        _context.Orders.Update(order);
+        return Task.CompletedTask;
+    }
+
+    /// <inheritdoc />
+    public async Task DeleteOrderAsync(long orderId, long tenantId, CancellationToken cancellationToken = default)
+    {
+        var items = await _context.OrderItems
+            .Where(x => x.TenantId == tenantId && x.OrderId == orderId)
+            .ToListAsync(cancellationToken);
+        if (items.Count > 0)
+        {
+            _context.OrderItems.RemoveRange(items);
+        }
+
+        var histories = await _context.OrderStatusHistories
+            .Where(x => x.TenantId == tenantId && x.OrderId == orderId)
+            .ToListAsync(cancellationToken);
+        if (histories.Count > 0)
+        {
+            _context.OrderStatusHistories.RemoveRange(histories);
+        }
+
+        var refunds = await _context.RefundRequests
+            .Where(x => x.TenantId == tenantId && x.OrderId == orderId)
+            .ToListAsync(cancellationToken);
+        if (refunds.Count > 0)
+        {
+            _context.RefundRequests.RemoveRange(refunds);
+        }
+
+        var existing = await _context.Orders
+            .Where(x => x.TenantId == tenantId && x.Id == orderId)
+            .FirstOrDefaultAsync(cancellationToken);
+        if (existing == null)
+        {
+            return;
+        }
+
+        _context.Orders.Remove(existing);
+    }
 }

src/Infrastructure/TakeoutSaaS.Infrastructure/App/Repositories/EfPaymentRepository.cs

@@ -68,4 +68,33 @@ public sealed class EfPaymentRepository : IPaymentRepository
     {
         return _context.SaveChangesAsync(cancellationToken);
     }
+
+    /// <inheritdoc />
+    public Task UpdatePaymentAsync(PaymentRecord payment, CancellationToken cancellationToken = default)
+    {
+        _context.PaymentRecords.Update(payment);
+        return Task.CompletedTask;
+    }
+
+    /// <inheritdoc />
+    public async Task DeletePaymentAsync(long paymentId, long tenantId, CancellationToken cancellationToken = default)
+    {
+        var refunds = await _context.PaymentRefundRecords
+            .Where(x => x.TenantId == tenantId && x.PaymentRecordId == paymentId)
+            .ToListAsync(cancellationToken);
+        if (refunds.Count > 0)
+        {
+            _context.PaymentRefundRecords.RemoveRange(refunds);
+        }
+
+        var existing = await _context.PaymentRecords
+            .Where(x => x.TenantId == tenantId && x.Id == paymentId)
+            .FirstOrDefaultAsync(cancellationToken);
+        if (existing == null)
+        {
+            return;
+        }
+
+        _context.PaymentRecords.Remove(existing);
+    }
 }

src/Infrastructure/TakeoutSaaS.Infrastructure/App/Repositories/EfProductRepository.cs

@@ -224,4 +224,163 @@ public sealed class EfProductRepository : IProductRepository
     {
         return _context.SaveChangesAsync(cancellationToken);
     }
+
+    /// <inheritdoc />
+    public Task UpdateProductAsync(Product product, CancellationToken cancellationToken = default)
+    {
+        _context.Products.Update(product);
+        return Task.CompletedTask;
+    }
+
+    /// <inheritdoc />
+    public async Task DeleteProductAsync(long productId, long tenantId, CancellationToken cancellationToken = default)
+    {
+        await RemovePricingRulesAsync(productId, tenantId, cancellationToken);
+        await RemoveMediaAssetsAsync(productId, tenantId, cancellationToken);
+        await RemoveAttributeGroupsAsync(productId, tenantId, cancellationToken);
+        await RemoveAddonGroupsAsync(productId, tenantId, cancellationToken);
+        await RemoveSkusAsync(productId, tenantId, cancellationToken);
+
+        var existing = await _context.Products
+            .Where(x => x.TenantId == tenantId && x.Id == productId)
+            .FirstOrDefaultAsync(cancellationToken);
+
+        if (existing == null)
+        {
+            return;
+        }
+
+        _context.Products.Remove(existing);
+    }
+
+    /// <inheritdoc />
+    public Task UpdateCategoryAsync(ProductCategory category, CancellationToken cancellationToken = default)
+    {
+        _context.ProductCategories.Update(category);
+        return Task.CompletedTask;
+    }
+
+    /// <inheritdoc />
+    public async Task DeleteCategoryAsync(long categoryId, long tenantId, CancellationToken cancellationToken = default)
+    {
+        var existing = await _context.ProductCategories
+            .Where(x => x.TenantId == tenantId && x.Id == categoryId)
+            .FirstOrDefaultAsync(cancellationToken);
+
+        if (existing == null)
+        {
+            return;
+        }
+
+        _context.ProductCategories.Remove(existing);
+    }
+
+    /// <inheritdoc />
+    public async Task RemoveSkusAsync(long productId, long tenantId, CancellationToken cancellationToken = default)
+    {
+        var skus = await _context.ProductSkus
+            .Where(x => x.TenantId == tenantId && x.ProductId == productId)
+            .ToListAsync(cancellationToken);
+
+        if (skus.Count == 0)
+        {
+            return;
+        }
+
+        _context.ProductSkus.RemoveRange(skus);
+    }
+
+    /// <inheritdoc />
+    public async Task RemoveAddonGroupsAsync(long productId, long tenantId, CancellationToken cancellationToken = default)
+    {
+        var groupIds = await _context.ProductAddonGroups
+            .Where(x => x.TenantId == tenantId && x.ProductId == productId)
+            .Select(x => x.Id)
+            .ToListAsync(cancellationToken);
+
+        if (groupIds.Count == 0)
+        {
+            return;
+        }
+
+        var options = await _context.ProductAddonOptions
+            .Where(x => x.TenantId == tenantId && groupIds.Contains(x.AddonGroupId))
+            .ToListAsync(cancellationToken);
+
+        if (options.Count > 0)
+        {
+            _context.ProductAddonOptions.RemoveRange(options);
+        }
+
+        var groups = await _context.ProductAddonGroups
+            .Where(x => groupIds.Contains(x.Id))
+            .ToListAsync(cancellationToken);
+
+        if (groups.Count > 0)
+        {
+            _context.ProductAddonGroups.RemoveRange(groups);
+        }
+    }
+
+    /// <inheritdoc />
+    public async Task RemoveAttributeGroupsAsync(long productId, long tenantId, CancellationToken cancellationToken = default)
+    {
+        var groupIds = await _context.ProductAttributeGroups
+            .Where(x => x.TenantId == tenantId && x.ProductId == productId)
+            .Select(x => x.Id)
+            .ToListAsync(cancellationToken);
+
+        if (groupIds.Count == 0)
+        {
+            return;
+        }
+
+        var options = await _context.ProductAttributeOptions
+            .Where(x => x.TenantId == tenantId && groupIds.Contains(x.AttributeGroupId))
+            .ToListAsync(cancellationToken);
+
+        if (options.Count > 0)
+        {
+            _context.ProductAttributeOptions.RemoveRange(options);
+        }
+
+        var groups = await _context.ProductAttributeGroups
+            .Where(x => groupIds.Contains(x.Id))
+            .ToListAsync(cancellationToken);
+
+        if (groups.Count > 0)
+        {
+            _context.ProductAttributeGroups.RemoveRange(groups);
+        }
+    }
+
+    /// <inheritdoc />
+    public async Task RemoveMediaAssetsAsync(long productId, long tenantId, CancellationToken cancellationToken = default)
+    {
+        var assets = await _context.ProductMediaAssets
+            .Where(x => x.TenantId == tenantId && x.ProductId == productId)
+            .ToListAsync(cancellationToken);
+
+        if (assets.Count == 0)
+        {
+            return;
+        }
+
+        _context.ProductMediaAssets.RemoveRange(assets);
+    }
+
+    /// <inheritdoc />
+    public async Task RemovePricingRulesAsync(long productId, long tenantId, CancellationToken cancellationToken = default)
+    {
+        var rules = await _context.ProductPricingRules
+            .Where(x => x.TenantId == tenantId && x.ProductId == productId)
+            .ToListAsync(cancellationToken);
+
+        if (rules.Count == 0)
+        {
+            return;
+        }
+
+        _context.ProductPricingRules.RemoveRange(rules);
+    }
 }

src/Infrastructure/TakeoutSaaS.Infrastructure/App/Repositories/EfStoreRepository.cs

@@ -171,4 +171,26 @@ public sealed class EfStoreRepository : IStoreRepository
     {
         return _context.SaveChangesAsync(cancellationToken);
     }
+
+    /// <inheritdoc />
+    public Task UpdateStoreAsync(Store store, CancellationToken cancellationToken = default)
+    {
+        _context.Stores.Update(store);
+        return Task.CompletedTask;
+    }
+
+    /// <inheritdoc />
+    public async Task DeleteStoreAsync(long storeId, long tenantId, CancellationToken cancellationToken = default)
+    {
+        var existing = await _context.Stores
+            .Where(x => x.TenantId == tenantId && x.Id == storeId)
+            .FirstOrDefaultAsync(cancellationToken);
+
+        if (existing == null)
+        {
+            return;
+        }
+
+        _context.Stores.Remove(existing);
+    }
 }