I-Synergy/I-Synergy.Framework.AspNetCore.MultiTenancyv2026.10226.11633

docs d<> code .compare c

✓ Verified.NET 10.0

I-Synergy Framework MultiTenancy

i-synergy.net ↗

License

MIT

Deps

Install Size

—

Vulns

✓ 0

Published

Feb 26, 2026

Get Started

$ dotnet add package I-Synergy.Framework.AspNetCore.MultiTenancy

Readme

I-Synergy Framework AspNetCore Multi-Tenancy

Multi-tenant architecture support for ASP.NET Core applications. This package provides tenant resolution from HTTP context, tenant service for managing tenant-specific operations, and integration with OpenIddict claims for secure multi-tenant applications.

Features

Tenant resolution from HTTP context and claims
Tenant service for accessing current tenant information
OpenIddict claims integration for secure tenant identification
HttpContext accessor for tenant management across request scope
User and tenant isolation with automatic group assignment
Programmatic tenant setting for testing and background jobs
Thread-safe tenant access throughout the application
Support for client roles in multi-tenant scenarios

Installation

Install the package via NuGet:

dotnet add package I-Synergy.Framework.AspNetCore.MultiTenancy

Quick Start

1. Configure Multi-Tenancy Services

In your Program.cs:

using ISynergy.Framework.AspNetCore.MultiTenancy.Extensions;

var builder = WebApplication.CreateBuilder(args);

// Add multi-tenancy support
builder.Services.AddMultiTenancyIntegration();

builder.Services.AddControllers();

var app = builder.Build();

app.UseAuthentication();
app.UseAuthorization();

app.MapControllers();
app.Run();

2. Using the Tenant Service

Access tenant information in your controllers and services:

using ISynergy.Framework.Core.Abstractions.Services;
using Microsoft.AspNetCore.Mvc;

[ApiController]
[Route("api/[controller]")]
[Authorize]
public class OrdersController : ControllerBase
{
    private readonly ITenantService _tenantService;
    private readonly IOrderRepository _orderRepository;

    public OrdersController(
        ITenantService tenantService,
        IOrderRepository orderRepository)
    {
        _tenantService = tenantService;
        _orderRepository = orderRepository;
    }

    [HttpGet]
    public async Task<IActionResult> GetOrders()
    {
        // Automatically filter by current tenant
        var tenantId = _tenantService.TenantId;
        var orders = await _orderRepository.GetByTenantAsync(tenantId);

        return Ok(orders);
    }

    [HttpPost]
    public async Task<IActionResult> CreateOrder([FromBody] CreateOrderRequest request)
    {
        var order = new Order
        {
            TenantId = _tenantService.TenantId,
            CreatedBy = _tenantService.UserName,
            // ... other properties
        };

        await _orderRepository.CreateAsync(order);

        return CreatedAtAction(nameof(GetOrder), new { id = order.Id }, order);
    }

    [HttpGet("{id}")]
    public async Task<IActionResult> GetOrder(int id)
    {
        var order = await _orderRepository.GetByIdAsync(id);

        // Verify tenant ownership
        if (order == null || order.TenantId != _tenantService.TenantId)
            return NotFound();

        return Ok(order);
    }
}

3. Setting Tenant Programmatically

For testing or background jobs, set the tenant context manually:

using ISynergy.Framework.Core.Abstractions.Services;

public class BackgroundJobService
{
    private readonly ITenantService _tenantService;

    public BackgroundJobService(ITenantService tenantService)
    {
        _tenantService = tenantService;
    }

    public async Task ProcessTenantDataAsync(Guid tenantId, string username)
    {
        // Set tenant context for this operation
        _tenantService.SetTenant(tenantId, username);

        // Now all operations will use this tenant context
        await ProcessDataAsync();
    }

    public async Task ProcessWithMinimalContextAsync(Guid tenantId)
    {
        // Set only tenant ID (no username)
        _tenantService.SetTenant(tenantId);

        await ProcessDataAsync();
    }
}

Core Components

Services

ISynergy.Framework.AspNetCore.MultiTenancy.Services/
└── TenantService                 # Tenant resolution and management

Extensions

ISynergy.Framework.AspNetCore.MultiTenancy.Extensions/
├── ServiceCollectionExtensions   # DI configuration
└── HostApplicationBuilderExtensions  # Builder configuration

Advanced Features

Tenant-Aware Entity Framework

Automatically filter queries by tenant:

using ISynergy.Framework.Core.Abstractions.Services;
using Microsoft.EntityFrameworkCore;

public class ApplicationDbContext : DbContext
{
    private readonly ITenantService _tenantService;

    public ApplicationDbContext(
        DbContextOptions<ApplicationDbContext> options,
        ITenantService tenantService)
        : base(options)
    {
        _tenantService = tenantService;
    }

    public DbSet<Order> Orders { get; set; }
    public DbSet<Product> Products { get; set; }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        base.OnModelCreating(modelBuilder);

        // Add global query filter for multi-tenancy
        modelBuilder.Entity<Order>()
            .HasQueryFilter(e => e.TenantId == _tenantService.TenantId);

        modelBuilder.Entity<Product>()
            .HasQueryFilter(e => e.TenantId == _tenantService.TenantId);
    }

    public override int SaveChanges()
    {
        ApplyTenantId();
        return base.SaveChanges();
    }

    public override async Task<int> SaveChangesAsync(CancellationToken cancellationToken = default)
    {
        ApplyTenantId();
        return await base.SaveChangesAsync(cancellationToken);
    }

    private void ApplyTenantId()
    {
        var tenantId = _tenantService.TenantId;

        foreach (var entry in ChangeTracker.Entries<ITenantEntity>())
        {
            if (entry.State == EntityState.Added)
            {
                entry.Entity.TenantId = tenantId;
            }
        }
    }
}

// Tenant entity interface
public interface ITenantEntity
{
    Guid TenantId { get; set; }
}

// Example entity
public class Order : ITenantEntity
{
    public int Id { get; set; }
    public Guid TenantId { get; set; }
    public string OrderNumber { get; set; }
    public decimal Amount { get; set; }
}

Tenant Resolution Middleware

Create custom middleware for tenant resolution:

using ISynergy.Framework.Core.Abstractions.Services;

public class TenantResolutionMiddleware
{
    private readonly RequestDelegate _next;

    public TenantResolutionMiddleware(RequestDelegate next)
    {
        _next = next;
    }

    public async Task InvokeAsync(HttpContext context, ITenantService tenantService)
    {
        // Option 1: From subdomain
        var host = context.Request.Host.Host;
        var subdomain = host.Split('.').FirstOrDefault();

        if (!string.IsNullOrEmpty(subdomain) && subdomain != "www")
        {
            var tenantId = await ResolveTenantFromSubdomainAsync(subdomain);
            if (tenantId.HasValue)
            {
                tenantService.SetTenant(tenantId.Value);
            }
        }

        // Option 2: From custom header
        if (context.Request.Headers.TryGetValue("X-Tenant-ID", out var tenantHeader))
        {
            if (Guid.TryParse(tenantHeader, out var tenantId))
            {
                tenantService.SetTenant(tenantId);
            }
        }

        // Option 3: Already set from claims by the framework
        // No action needed - TenantService reads from User claims

        await _next(context);
    }

    private async Task<Guid?> ResolveTenantFromSubdomainAsync(string subdomain)
    {
        // Lookup tenant by subdomain
        // Return tenant ID or null
        return Guid.Empty; // Placeholder
    }
}

// Register middleware
app.UseMiddleware<TenantResolutionMiddleware>();

Tenant-Specific Configuration

Manage tenant-specific settings:

using ISynergy.Framework.Core.Abstractions.Services;

public class TenantConfigurationService
{
    private readonly ITenantService _tenantService;
    private readonly IConfiguration _configuration;

    public TenantConfigurationService(
        ITenantService tenantService,
        IConfiguration configuration)
    {
        _tenantService = tenantService;
        _configuration = configuration;
    }

    public string GetTenantSetting(string key)
    {
        var tenantId = _tenantService.TenantId;
        var tenantKey = $"Tenants:{tenantId}:{key}";

        return _configuration[tenantKey] ?? _configuration[key];
    }

    public T GetTenantSetting<T>(string key, T defaultValue = default)
    {
        var value = GetTenantSetting(key);

        if (string.IsNullOrEmpty(value))
            return defaultValue;

        return (T)Convert.ChangeType(value, typeof(T));
    }
}

// appsettings.json
{
  "Tenants": {
    "123e4567-e89b-12d3-a456-426614174000": {
      "MaxUsers": 100,
      "StorageQuotaGB": 50,
      "Features": ["AdvancedReporting", "API"]
    },
    "987fcdeb-51a2-43f1-9876-543210fedcba": {
      "MaxUsers": 10,
      "StorageQuotaGB": 5,
      "Features": ["BasicReporting"]
    }
  }
}

Tenant Isolation Validation

Ensure tenant isolation in critical operations:

using ISynergy.Framework.Core.Abstractions.Services;

public class TenantIsolationValidator
{
    private readonly ITenantService _tenantService;

    public TenantIsolationValidator(ITenantService tenantService)
    {
        _tenantService = tenantService;
    }

    public void ValidateTenantAccess<T>(T entity) where T : ITenantEntity
    {
        if (entity.TenantId != _tenantService.TenantId)
        {
            throw new UnauthorizedAccessException(
                $"Access denied. Entity belongs to different tenant.");
        }
    }

    public void ValidateTenantAccess(Guid tenantId)
    {
        if (tenantId != _tenantService.TenantId)
        {
            throw new UnauthorizedAccessException(
                $"Access denied. Operation for different tenant.");
        }
    }
}

// Usage in service
public class OrderService
{
    private readonly ITenantService _tenantService;
    private readonly TenantIsolationValidator _validator;
    private readonly IOrderRepository _repository;

    public OrderService(
        ITenantService tenantService,
        TenantIsolationValidator validator,
        IOrderRepository repository)
    {
        _tenantService = tenantService;
        _validator = validator;
        _repository = repository;
    }

    public async Task DeleteOrderAsync(int orderId)
    {
        var order = await _repository.GetByIdAsync(orderId);

        if (order == null)
            throw new NotFoundException("Order not found");

        // Validate tenant isolation
        _validator.ValidateTenantAccess(order);

        await _repository.DeleteAsync(order);
    }
}

Usage Examples

Multi-Tenant SaaS Application

Complete example of a multi-tenant SaaS application:

using ISynergy.Framework.AspNetCore.MultiTenancy.Extensions;
using ISynergy.Framework.Core.Abstractions.Services;

var builder = WebApplication.CreateBuilder(args);

// Add multi-tenancy
builder.Services.AddMultiTenancyIntegration();

// Add authentication with OpenIddict
builder.Services.AddAuthentication("OpenIddict.Validation.AspNetCore")
    .AddOpenIddictValidation(options =>
    {
        options.SetIssuer("https://auth.example.com");
    });

builder.Services.AddControllers();

var app = builder.Build();

app.UseAuthentication();
app.UseAuthorization();

app.MapControllers();
app.Run();

// Customer Controller
[ApiController]
[Route("api/[controller]")]
[Authorize]
public class CustomersController : ControllerBase
{
    private readonly ITenantService _tenantService;
    private readonly ICustomerRepository _customerRepository;

    public CustomersController(
        ITenantService tenantService,
        ICustomerRepository customerRepository)
    {
        _tenantService = tenantService;
        _customerRepository = customerRepository;
    }

    [HttpGet]
    public async Task<IActionResult> GetCustomers()
    {
        // Automatically scoped to current tenant
        var customers = await _customerRepository
            .GetAllAsync(_tenantService.TenantId);

        return Ok(customers);
    }

    [HttpPost]
    public async Task<IActionResult> CreateCustomer([FromBody] CreateCustomerRequest request)
    {
        var customer = new Customer
        {
            TenantId = _tenantService.TenantId,
            Name = request.Name,
            Email = request.Email,
            CreatedBy = _tenantService.UserName,
            CreatedAt = DateTime.UtcNow
        };

        await _customerRepository.CreateAsync(customer);

        return CreatedAtAction(nameof(GetCustomer), new { id = customer.Id }, customer);
    }

    [HttpGet("{id}")]
    public async Task<IActionResult> GetCustomer(int id)
    {
        var customer = await _customerRepository.GetByIdAsync(id);

        // Verify tenant ownership
        if (customer == null || customer.TenantId != _tenantService.TenantId)
            return NotFound();

        return Ok(customer);
    }

    [HttpPut("{id}")]
    public async Task<IActionResult> UpdateCustomer(int id, [FromBody] UpdateCustomerRequest request)
    {
        var customer = await _customerRepository.GetByIdAsync(id);

        if (customer == null || customer.TenantId != _tenantService.TenantId)
            return NotFound();

        customer.Name = request.Name;
        customer.Email = request.Email;
        customer.UpdatedBy = _tenantService.UserName;
        customer.UpdatedAt = DateTime.UtcNow;

        await _customerRepository.UpdateAsync(customer);

        return Ok(customer);
    }

    [HttpDelete("{id}")]
    public async Task<IActionResult> DeleteCustomer(int id)
    {
        var customer = await _customerRepository.GetByIdAsync(id);

        if (customer == null || customer.TenantId != _tenantService.TenantId)
            return NotFound();

        await _customerRepository.DeleteAsync(customer);

        return NoContent();
    }
}

Background Job with Tenant Context

Process tenant-specific background jobs:

using ISynergy.Framework.Core.Abstractions.Services;

public class TenantReportGenerator
{
    private readonly ITenantService _tenantService;
    private readonly IReportService _reportService;
    private readonly IEmailService _emailService;

    public TenantReportGenerator(
        ITenantService tenantService,
        IReportService reportService,
        IEmailService emailService)
    {
        _tenantService = tenantService;
        _reportService = reportService;
        _emailService = emailService;
    }

    public async Task GenerateMonthlyReportsAsync()
    {
        var tenants = await GetAllTenantsAsync();

        foreach (var tenant in tenants)
        {
            // Set tenant context for this iteration
            _tenantService.SetTenant(tenant.Id, "system");

            try
            {
                // Generate report (automatically scoped to tenant)
                var report = await _reportService.GenerateMonthlyReportAsync();

                // Send email to tenant administrators
                await _emailService.SendReportAsync(tenant.AdminEmail, report);
            }
            catch (Exception ex)
            {
                // Log error for this tenant
                Console.WriteLine($"Error generating report for tenant {tenant.Id}: {ex.Message}");
            }
        }
    }
}

Integration Testing with Tenant Context

Test multi-tenant features:

using ISynergy.Framework.Core.Abstractions.Services;
using Microsoft.AspNetCore.Mvc.Testing;
using Xunit;

public class CustomerControllerTests : IClassFixture<WebApplicationFactory<Program>>
{
    private readonly WebApplicationFactory<Program> _factory;

    public CustomerControllerTests(WebApplicationFactory<Program> factory)
    {
        _factory = factory;
    }

    [Fact]
    public async Task GetCustomers_ReturnOnlyTenantCustomers()
    {
        // Arrange
        var tenant1Id = Guid.NewGuid();
        var tenant2Id = Guid.NewGuid();

        var client = _factory.CreateClient();

        // Seed data for two tenants
        await SeedCustomersAsync(tenant1Id, 5);
        await SeedCustomersAsync(tenant2Id, 3);

        // Act - Request with tenant1 context
        var response = await client.GetAsync($"/api/customers");

        // Assert
        response.EnsureSuccessStatusCode();
        var customers = await response.Content.ReadFromJsonAsync<List<Customer>>();

        Assert.Equal(5, customers.Count);
        Assert.All(customers, c => Assert.Equal(tenant1Id, c.TenantId));
    }

    [Fact]
    public async Task CreateCustomer_AssignCurrentTenant()
    {
        // Arrange
        var tenantId = Guid.NewGuid();
        var client = _factory.CreateClient();

        // Act
        var response = await client.PostAsJsonAsync("/api/customers", new
        {
            Name = "Test Customer",
            Email = "test@example.com"
        });

        // Assert
        response.EnsureSuccessStatusCode();
        var customer = await response.Content.ReadFromJsonAsync<Customer>();

        Assert.Equal(tenantId, customer.TenantId);
    }
}

Best Practices

[!TIP] Use global query filters in Entity Framework to automatically scope queries to the current tenant.

[!IMPORTANT] Always validate tenant ownership before modifying or deleting entities to prevent cross-tenant data access.

[!NOTE] Set the tenant context early in the request pipeline (authentication/authorization middleware) for consistent behavior.

Tenant Resolution

Resolve tenant from claims when using authentication
Use subdomain or custom headers for public APIs
Set tenant context in middleware for consistency
Cache tenant information to avoid repeated lookups
Handle missing or invalid tenant gracefully
Log tenant context for audit trails

Data Isolation

Use global query filters in Entity Framework
Always validate tenant ownership before operations
Implement tenant checks in repository layer
Use database schemas or separate databases for strict isolation
Audit cross-tenant access attempts
Test tenant isolation thoroughly

Security

Never trust tenant ID from client input
Always validate tenant from authenticated claims
Implement role-based access within tenants
Monitor suspicious cross-tenant access patterns
Use separate connection strings for high-security tenants
Encrypt tenant-specific sensitive data

Performance

Cache tenant configuration and settings
Use indexes on TenantId columns
Consider database-per-tenant for large tenants
Implement tenant-aware caching strategies
Monitor query performance across tenants
Optimize global query filters

Testing

Example unit tests for multi-tenancy:

using ISynergy.Framework.Core.Abstractions.Services;
using Microsoft.AspNetCore.Http;
using Moq;
using System.Security.Claims;
using Xunit;

public class TenantServiceTests
{
    [Fact]
    public void TenantId_WithValidClaim_ReturnsTenantId()
    {
        // Arrange
        var tenantId = Guid.NewGuid();
        var claims = new[]
        {
            new Claim(Claims.KeyId, tenantId.ToString())
        };
        var identity = new ClaimsIdentity(claims);
        var principal = new ClaimsPrincipal(identity);

        var httpContext = new DefaultHttpContext
        {
            User = principal
        };

        var httpContextAccessor = new Mock<IHttpContextAccessor>();
        httpContextAccessor.Setup(a => a.HttpContext).Returns(httpContext);

        var tenantService = new TenantService(httpContextAccessor.Object);

        // Act
        var result = tenantService.TenantId;

        // Assert
        Assert.Equal(tenantId, result);
    }

    [Fact]
    public void SetTenant_SetsClaimsPrincipal()
    {
        // Arrange
        var tenantId = Guid.NewGuid();
        var username = "testuser";

        var httpContext = new DefaultHttpContext();
        var httpContextAccessor = new Mock<IHttpContextAccessor>();
        httpContextAccessor.Setup(a => a.HttpContext).Returns(httpContext);

        var tenantService = new TenantService(httpContextAccessor.Object);

        // Act
        tenantService.SetTenant(tenantId, username);

        // Assert
        Assert.Equal(tenantId.ToString(), httpContext.User.FindFirst(Claims.KeyId)?.Value);
        Assert.Equal(username, httpContext.User.FindFirst(Claims.Username)?.Value);
    }
}

Dependencies

Microsoft.AspNetCore.Http - HTTP context abstractions
OpenIddict.Abstractions - OAuth 2.0/OpenID Connect claims
ISynergy.Framework.Core - Core framework utilities

Documentation

For more information about the I-Synergy Framework:

Related Packages

I-Synergy.Framework.Core - Core framework components
I-Synergy.Framework.AspNetCore - Base ASP.NET Core integration
I-Synergy.Framework.AspNetCore.Authentication - Authentication utilities
I-Synergy.Framework.EntityFramework - Entity Framework with tenant support
I-Synergy.Framework.AspNetCore.Monitoring - SignalR monitoring with tenant isolation

Support

For issues, questions, or contributions, please visit the GitHub repository.

Total Downloads

177.4K

Compatibility

.NET 10.0

Versions

2026.10226.11633Latest

Feb 26, 2026

Other versions (266)

2026.10217.10039Feb 17, 2026

2026.10214.10109Feb 16, 2026

2026.10211.12302Feb 11, 2026

2026.10201.12332Feb 1, 2026

2026.10110.10203Jan 10, 2026

2025.11225.12213Dec 25, 2025

2025.11218.11301Dec 18, 2025

2025.11209.11459Dec 9, 2025

2025.11130.12248Nov 30, 2025

2025.11120.10114Nov 20, 2025

2025.11119.10110Nov 19, 2025

2025.10413.11530Apr 13, 2025

2025.10412.10141Apr 12, 2025

2025.10320.11800Mar 20, 2025

2025.10320.10000Mar 19, 2025

2025.10318.10055Mar 18, 2025

2025.10305.12342Mar 5, 2025

2025.10301.12313Mar 1, 2025

2025.1051.1246Feb 20, 2025

2025.1044.1Feb 13, 2025

2025.1038.1Feb 7, 2025

2025.1035.1Feb 4, 2025

2025.1034.1Feb 3, 2025

2025.1025.1Jan 25, 2025

2025.1021.1Jan 21, 2025

2025.1020.1Jan 20, 2025

2025.1010.1Jan 10, 2025

2025.1007.1Jan 7, 2025

2025.1006.1Jan 7, 2025

2025.1005.1Jan 5, 2025

2025.1004.1Jan 4, 2025

2024.1366.1Dec 31, 2024

2024.1351.1Dec 16, 2024

2024.1350.1Dec 15, 2024

2024.1343.1Dec 8, 2024

2024.1339.1Dec 4, 2024

2024.1336.1Dec 1, 2024

2024.1332.1Nov 27, 2024

2024.1330.1Nov 25, 2024

2024.1328.1Nov 23, 2024

2024.1325.1Nov 20, 2024

2024.1323.1Nov 18, 2024

2024.1316.1Nov 11, 2024

2024.1307.1Nov 2, 2024

2024.1300.1Oct 26, 2024

2024.1294.1Oct 20, 2024

2024.1290.1Oct 16, 2024

2024.1283.1Oct 8, 2024

2024.1282.1Oct 8, 2024

2024.1278.1Oct 4, 2024

2024.1277.1Oct 3, 2024

2024.1275.2Oct 1, 2024

2024.1275.1Oct 1, 2024

2024.1274.1Sep 30, 2024

2024.1263.1Sep 19, 2024

2024.1261.1Sep 17, 2024

2024.1258.1Sep 13, 2024

2024.1257.1Sep 13, 2024

2024.1256.1Sep 12, 2024

2024.1254.1Sep 10, 2024

2024.1250.1Sep 6, 2024

2024.1249.1Sep 5, 2024

2024.1246.1Sep 2, 2024

2024.1245.1Sep 1, 2024

2024.1237.1Aug 24, 2024

2024.1230.1Aug 18, 2024

2024.1229.1Aug 16, 2024

2024.1228.1Aug 15, 2024

2024.1222.1Aug 8, 2024

2024.1221.1Aug 7, 2024

2024.1220.1Aug 7, 2024

2024.1166.1Jun 14, 2024

2024.1165.1Jun 13, 2024

2024.1164.1Jun 12, 2024

2024.1162.1Jun 10, 2024

2024.1158.1Jun 6, 2024

2024.1156.1Jun 4, 2024

2024.1152.1May 31, 2024

2024.1151.1May 29, 2024

2024.1150.2May 29, 2024

2024.1150.1May 29, 2024

2024.1149.1May 28, 2024

2024.1147.1May 26, 2024

2024.1146.2May 25, 2024

2024.1146.1May 25, 2024

2024.1145.1May 24, 2024

2024.1135.2May 14, 2024

2024.1135.1May 14, 2024

2024.1134.1May 13, 2024

2024.1130.1May 9, 2024

2024.1123.1May 2, 2024

2024.1121.1Apr 30, 2024

2024.1114.1Apr 22, 2024

2024.1094.2Apr 3, 2024

2024.1094.1Apr 3, 2024

2024.1092.1Apr 1, 2024

2024.1088.1Mar 28, 2024

2024.1085.1Mar 25, 2024

2024.1080.2Mar 20, 2024

2024.1080.1Mar 20, 2024

2024.1078.1Mar 18, 2024

2024.1077.1Mar 17, 2024

2024.1073.1Mar 13, 2024

2024.1070.1Mar 10, 2024

2024.1069.1Mar 9, 2024

2024.1068.1Mar 8, 2024

2024.1066.2Mar 6, 2024

2024.1066.1Mar 6, 2024

2024.1065.1Mar 5, 2024

2024.1063.2Mar 3, 2024

2024.1063.1Mar 3, 2024

2024.1062.1Mar 2, 2024

2024.1061.2Mar 1, 2024

2024.1061.1Mar 1, 2024

2024.1060.2Feb 29, 2024

2024.1060.1Feb 29, 2024

2024.1058.1Feb 27, 2024

2024.1056.1Feb 25, 2024

2024.1055.1Feb 24, 2024

2024.1052.1Feb 21, 2024

2024.1050.2Feb 20, 2024

2024.1050.1Feb 19, 2024

2024.1049.1Feb 18, 2024

2024.1048.1Feb 17, 2024

2024.1047.1Feb 16, 2024

2024.1035.1Feb 4, 2024

2024.1034.2Feb 3, 2024

2024.1029.1Jan 29, 2024

2024.1023.1Jan 23, 2024

2024.1022.1Jan 22, 2024

2024.1020.1Jan 20, 2024

2024.1019.1Jan 19, 2024

2024.1017.1Jan 17, 2024

2024.1012.1Jan 12, 2024

2024.1010.1Jan 10, 2024

2024.1008.1Jan 8, 2024

2024.1007.1Jan 7, 2024

2024.1005.1Jan 5, 2024

2024.1004.1Jan 4, 2024

2023.1365.1Dec 31, 2023

2023.1362.1Dec 28, 2023

2023.1361.1Dec 27, 2023

2023.1359.1Dec 25, 2023

2023.1358.1Dec 24, 2023

2023.1357.1Dec 23, 2023

2023.1342.1Dec 8, 2023

2023.1336.1Dec 2, 2023

2023.1332.1Nov 28, 2023

2023.1330.1Nov 26, 2023

2023.1325.1Nov 21, 2023

2023.1323.1Nov 19, 2023

2023.1320.1Nov 17, 2023

2023.1318.1Nov 15, 2023

2023.1317.1Nov 13, 2023

2023.1307.1Nov 3, 2023

2023.1305.1Nov 1, 2023

2023.1304.1Oct 31, 2023

2023.1294.1Oct 21, 2023

2023.1290.1Oct 16, 2023

2023.1289.1Oct 16, 2023

2023.1284.1Oct 11, 2023

2023.1276.1Oct 3, 2023

2023.1275.1Oct 2, 2023

2023.1272.1Sep 29, 2023

2023.1269.1Sep 26, 2023

2023.1242.1Aug 30, 2023

2023.1231.1Aug 19, 2023

2023.1229.1Aug 17, 2023

2023.1228.1Aug 16, 2023

2023.1227.1Aug 15, 2023

2023.1224.2Aug 12, 2023

2023.1224.1Aug 12, 2023

2023.1213.2Aug 1, 2023

2023.1213.1Aug 1, 2023

2023.1209.1Jul 27, 2023

2023.1201.1Jul 20, 2023

2023.1197.1Jul 16, 2023

2023.1178.1Jun 27, 2023

2023.1175.1Jun 24, 2023

2023.1174.1Jun 22, 2023

2023.1169.1Jun 18, 2023

2023.1165.1Jun 14, 2023

2023.1161.1Jun 11, 2023

2023.1159.1Jun 7, 2023

2023.1157.1Jun 6, 2023

2023.1146.1May 27, 2023

2023.1139.1May 19, 2023

2023.1137.1May 17, 2023

2023.1136.1May 16, 2023

2023.1118.1Apr 28, 2023

2023.1111.1Apr 21, 2023

2023.1110.1Apr 20, 2023

2023.1105.1Apr 15, 2023

2023.1103.1Apr 13, 2023

2023.1102.1Apr 12, 2023

2023.1101.1Apr 11, 2023

2023.1090.1Mar 31, 2023

2023.1089.1Mar 30, 2023

2023.1088.1Mar 29, 2023

2023.1082.1Mar 23, 2023

2023.1078.1Mar 19, 2023

2023.1075.1Mar 16, 2023

2023.1070.1Mar 11, 2023

2023.1069.1Mar 10, 2023

2023.1064.1Mar 5, 2023

2023.1060.1Mar 1, 2023

2023.1057.1Feb 26, 2023

2023.1046.1Feb 15, 2023

2023.1043.2Feb 12, 2023

2023.1043.1Feb 12, 2023

2023.1042.1Feb 11, 2023

2023.1041.1Feb 10, 2023

2023.1039.1Feb 8, 2023

2023.1036.1Feb 5, 2023

2023.1035.1Feb 4, 2023

2023.1033.1Feb 2, 2023

2023.1030.1Jan 30, 2023

2023.1028.1Jan 28, 2023

2023.1026.1Jan 26, 2023

2023.1025.1Jan 25, 2023

2023.1024.1Jan 24, 2023

2023.1023.1Jan 23, 2023

2022.1319.1Nov 15, 2022

2022.1309.1Nov 5, 2022

2022.1307.1Nov 3, 2022

2022.1295.1Oct 22, 2022

2022.1290.1Oct 17, 2022

2022.1289.2Oct 16, 2022

2022.1289.1Oct 16, 2022

2022.1283.1Oct 10, 2022

2022.1282.1Oct 9, 2022

2022.1278.1Oct 5, 2022

2022.1272.2Sep 29, 2022

2022.1272.1Sep 29, 2022

2022.1271.1Sep 28, 2022

2022.1266.1Sep 23, 2022

2022.1259.1Sep 16, 2022

2022.1257.1Sep 14, 2022

2022.1250.1Sep 7, 2022

2022.1197.1Jul 16, 2022

2022.1196.1Jul 15, 2022

2022.1194.1Jul 13, 2022

2022.1182.1Jul 1, 2022

2022.1178.1Jun 27, 2022

2022.1166.1Jun 15, 2022

2022.1157.1Jun 6, 2022

2022.1150.1May 30, 2022

2022.1149.1May 29, 2022

2022.1144.1May 24, 2022

0.6.2May 23, 2022

0.6.1May 23, 2022

0.6.0May 14, 2022

0.5.3May 8, 2022

0.5.2May 1, 2022

0.5.1May 1, 2022

0.5.0Apr 23, 2022

0.4.1Apr 15, 2022

0.4.0Apr 9, 2022

0.3.3Apr 8, 2022

0.3.2Apr 1, 2022

0.3.1Mar 29, 2022

0.3.0Mar 28, 2022

0.2.3Mar 28, 2022

0.2.2Mar 25, 2022

0.2.1Mar 21, 2022

0.2.0Mar 18, 2022