10.

Implementation
A partner, not just software
HexDive Technologies' local team handles setup, data migration, training and ongoing support — in Sinhala, Tamil and English. [confirm]

1
Discovery
Map your network, products and processes.

2
Configuration
Set up depots, pricing, schemes, routes and users.

3
Migration & training
Move your data and train every team.

4
Go-live & support
Dedicated account manager and local support desk.

.gitea/workflows/ci-cd.yml

@@ -0,0 +1,89 @@
+name: CI/CD - ERP Distribution
+on:
+  pull_request:
+    branches:
+      - production
+    types:
+      - closed
+jobs:
+  build-and-deploy-backend:
+    name: Build & Deploy Backend
+    runs-on: linux
+    if: github.event.pull_request.merged == true
+    steps:
+      - name: Checkout code
+        run: |
+          git clone \
+            --depth 1 \
+            --branch production \
+            https://oauth2:${{ secrets.DISTRIBUTION }}@gitea.hexdive.com/New_REP_SYSTEM/ERP_Distribution.git \
+            .
+      - name: Restore
+        run: dotnet restore Distribution/Distribution.csproj
+      - name: Publish
+        run: |
+          rm -rf /tmp/erpdistribution-deploy
+          mkdir -p /tmp/erpdistribution-deploy
+          dotnet publish Distribution/Distribution.csproj \
+            -c Release \
+            -r linux-x64 \
+            --self-contained true \
+            -o /tmp/erpdistribution-deploy
+      - name: Stop service
+        run: systemctl stop erpdistribution.service
+      - name: Copy to deploy folder
+        run: |
+          mkdir -p /home/distribution/core/publish
+          rm -rf /home/distribution/core/publish/*
+          cp -r /tmp/erpdistribution-deploy/* /home/distribution/core/publish/
+      - name: Fix ownership and permissions
+        run: |
+          chown -R distributionuser:distributionuser /home/distribution/core/publish
+          find /home/distribution/core/publish -type d -exec chmod 755 {} +
+          find /home/distribution/core/publish -type f -exec chmod 644 {} +
+          chmod +x /home/distribution/core/publish/Distribution
+      - name: Restart service
+        run: systemctl restart erpdistribution.service
+      - name: Verify
+        run: |
+          systemctl is-active erpdistribution.service && echo "✅ Service running" || echo "❌ Service failed"
+
+  build-and-deploy-frontend:
+    name: Build & Deploy Frontend
+    runs-on: linux
+    if: github.event.pull_request.merged == true
+    steps:
+      - name: Checkout code
+        run: |
+          git clone \
+            --depth 1 \
+            --branch production \
+            https://oauth2:${{ secrets.DISTRIBUTION }}@gitea.hexdive.com/New_REP_SYSTEM/ERP_Distribution.git \
+            .
+      - name: Build Docker image
+        run: |
+          docker build --progress=plain --no-cache \
+            --build-arg NEXT_PUBLIC_API_URL=https://distribution.hexdive.com/api \
+            -t erpdistributionfe:latest \
+            ./distribution_fe
+      - name: Stop & remove existing container
+        run: |
+          docker stop erpdistributionfe 2>/dev/null || true
+          docker rm erpdistributionfe 2>/dev/null || true
+      - name: Start container
+        run: |
+          docker run -d \
+            --name erpdistributionfe \
+            -p 8801:3000 \
+            --restart unless-stopped \
+            --memory="512m" \
+            --cpus="1.0" \
+            --cap-drop ALL \
+            --security-opt no-new-privileges \
+            erpdistributionfe:latest
+      - name: Remove old images
+        run: docker image prune -f
+      - name: Verify
+        run: |
+          docker ps --filter name=erpdistributionfe --format "table {{.Names}}\t{{.Status}}\t{{.Ports}}" \
+            | grep erpdistributionfe && echo "✅ Container running" || echo "❌ Container failed"

Distribution.Tests/Distribution.Tests.csproj

@@ -0,0 +1,28 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net9.0</TargetFramework>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
+    <PackageReference Include="xunit" Version="2.9.3" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.8.2">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
+    <PackageReference Include="Moq" Version="4.20.72" />
+    <PackageReference Include="coverlet.collector" Version="6.0.2">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Distribution\Distribution.csproj" />
+  </ItemGroup>
+
+</Project>

Distribution.Tests/Services/AuthServiceTests.cs

@@ -0,0 +1,99 @@
+using Distribution.Features.Auth;
+using Distribution.Features.User;
+using Distribution.Infra.Authorization;
+using Distribution.Models;
+using Microsoft.AspNetCore.Identity;
+using Moq;
+using Xunit;
+
+namespace Distribution.Tests.Services;
+
+public class AuthServiceTests
+{
+    private readonly Mock<IUserRepository> _userRepo = new();
+    private readonly Mock<IJwtTokenService> _tokenService = new();
+    private readonly AuthService _sut;
+    private readonly PasswordHasher<User> _hasher = new();
+
+    public AuthServiceTests()
+    {
+        _sut = new AuthService(_userRepo.Object, _tokenService.Object);
+    }
+
+    private User ActiveUserWithPassword(string password) => new()
+    {
+        Id = Guid.NewGuid(),
+        Username = "testuser",
+        FullName = "Test User",
+        IsActive = true,
+        FK_RoleId = Guid.NewGuid(),
+        PasswordHash = _hasher.HashPassword(null!, password),
+        Role = new Role { Name = "Sales", Level = 10 }
+    };
+
+    // LoginAsync
+
+    [Fact]
+    public async Task LoginAsync_ReturnsNull_WhenUserNotFound()
+    {
+        _userRepo.Setup(r => r.GetByUsernameAsync(It.IsAny<string>())).ReturnsAsync((User?)null);
+
+        var result = await _sut.LoginAsync(new LoginRequest("nobody", "pass"));
+
+        Assert.Null(result);
+        _tokenService.Verify(t => t.GenerateToken(It.IsAny<User>()), Times.Never);
+    }
+
+    [Fact]
+    public async Task LoginAsync_ReturnsNull_WhenUserIsInactive()
+    {
+        var user = ActiveUserWithPassword("secret");
+        user.IsActive = false;
+        _userRepo.Setup(r => r.GetByUsernameAsync("testuser")).ReturnsAsync(user);
+
+        var result = await _sut.LoginAsync(new LoginRequest("testuser", "secret"));
+
+        Assert.Null(result);
+        _tokenService.Verify(t => t.GenerateToken(It.IsAny<User>()), Times.Never);
+    }
+
+    [Fact]
+    public async Task LoginAsync_ReturnsNull_WhenPasswordIsWrong()
+    {
+        var user = ActiveUserWithPassword("correct");
+        _userRepo.Setup(r => r.GetByUsernameAsync("testuser")).ReturnsAsync(user);
+
+        var result = await _sut.LoginAsync(new LoginRequest("testuser", "wrong"));
+
+        Assert.Null(result);
+        _tokenService.Verify(t => t.GenerateToken(It.IsAny<User>()), Times.Never);
+    }
+
+    [Fact]
+    public async Task LoginAsync_ReturnsLoginResponse_WhenCredentialsAreValid()
+    {
+        var user = ActiveUserWithPassword("secret");
+        _userRepo.Setup(r => r.GetByUsernameAsync("testuser")).ReturnsAsync(user);
+        _tokenService.Setup(t => t.GenerateToken(user)).Returns("jwt-token");
+
+        var result = await _sut.LoginAsync(new LoginRequest("testuser", "secret"));
+
+        Assert.NotNull(result);
+        Assert.Equal("jwt-token", result.Token);
+        Assert.Equal(user.Id, result.UserId);
+        Assert.Equal("testuser", result.Username);
+        Assert.Equal("Sales", result.RoleName);
+    }
+
+    [Fact]
+    public async Task LoginAsync_CallsGenerateToken_OnSuccess()
+    {
+        var user = ActiveUserWithPassword("pass");
+        _userRepo.Setup(r => r.GetByUsernameAsync(It.IsAny<string>())).ReturnsAsync(user);
+        _tokenService.Setup(t => t.GenerateToken(user)).Returns("token");
+
+        await _sut.LoginAsync(new LoginRequest("testuser", "pass"));
+
+        _tokenService.Verify(t => t.GenerateToken(user), Times.Once);
+    }
+}

Distribution.Tests/Services/ItemServiceTests.cs

@@ -0,0 +1,259 @@
+using Distribution.Features.Item;
+using Distribution.Infra.UoW;
+using Distribution.Models;
+using Moq;
+using Xunit;
+
+namespace Distribution.Tests.Services;
+
+public class ItemServiceTests
+{
+    private readonly Mock<IItemRepository> _repo = new();
+    private readonly Mock<IUnitOfWork> _uow = new();
+    private readonly ItemService _sut;
+
+    public ItemServiceTests()
+    {
+        _sut = new ItemService(_repo.Object, _uow.Object);
+    }
+
+    private static Item ManualItem(string sku = "SKU-001") => new()
+    {
+        Id = Guid.NewGuid(),
+        Sku = sku,
+        Name = "Test Item",
+        IsActive = true,
+        SyncSource = SyncSource.Manual,
+        FK_CategoryId = Guid.NewGuid(),
+        FK_BaseUomId = Guid.NewGuid(),
+        Category = new Category { Name = "Cat" },
+        BaseUom = new Uom { Name = "Each" },
+        Conversions = []
+    };
+
+    private static Item ErpItem() => new()
+    {
+        Id = Guid.NewGuid(),
+        Sku = "ERP-001",
+        Name = "Erp Item",
+        IsActive = true,
+        SyncSource = SyncSource.Erp,
+        FK_CategoryId = Guid.NewGuid(),
+        FK_BaseUomId = Guid.NewGuid(),
+        Category = new Category { Name = "Cat" },
+        BaseUom = new Uom { Name = "Each" },
+        Conversions = []
+    };
+
+    private static Item InactiveItem() => new()
+    {
+        Id = Guid.NewGuid(),
+        Sku = "OLD-001",
+        Name = "Old",
+        IsActive = false,
+        SyncSource = SyncSource.Manual,
+        FK_CategoryId = Guid.NewGuid(),
+        FK_BaseUomId = Guid.NewGuid(),
+        Category = new Category { Name = "Cat" },
+        BaseUom = new Uom { Name = "Each" },
+        Conversions = []
+    };
+
+    private static CreateItemRequest SampleCreateRequest(string sku = "SKU-001") =>
+        new(sku, "Test Item", null, Guid.NewGuid(), null, null, Guid.NewGuid(), null, null);
+
+    // CreateAsync
+
+    [Fact]
+    public async Task CreateAsync_Throws_WhenSkuAlreadyExists()
+    {
+        _repo.Setup(r => r.SkuExistsAsync(It.IsAny<string>(), It.IsAny<Guid?>())).ReturnsAsync(true);
+
+        await Assert.ThrowsAsync<InvalidOperationException>(
+            () => _sut.CreateAsync(SampleCreateRequest("DUP")));
+
+        _repo.Verify(r => r.AddAsync(It.IsAny<Item>()), Times.Never);
+    }
+
+    [Fact]
+    public async Task CreateAsync_SetsManualSyncSource()
+    {
+        var item = ManualItem();
+        _repo.Setup(r => r.SkuExistsAsync(It.IsAny<string>(), It.IsAny<Guid?>())).ReturnsAsync(false);
+        _repo.Setup(r => r.AddAsync(It.IsAny<Item>())).Returns(Task.CompletedTask);
+        _repo.Setup(r => r.GetByIdAsync(It.IsAny<Guid>())).ReturnsAsync(item);
+
+        await _sut.CreateAsync(SampleCreateRequest());
+
+        _repo.Verify(r => r.AddAsync(It.Is<Item>(i => i.SyncSource == SyncSource.Manual)), Times.Once);
+    }
+
+    [Fact]
+    public async Task CreateAsync_BeginsAndCommitsTransaction()
+    {
+        var item = ManualItem();
+        _repo.Setup(r => r.SkuExistsAsync(It.IsAny<string>(), It.IsAny<Guid?>())).ReturnsAsync(false);
+        _repo.Setup(r => r.AddAsync(It.IsAny<Item>())).Returns(Task.CompletedTask);
+        _repo.Setup(r => r.GetByIdAsync(It.IsAny<Guid>())).ReturnsAsync(item);
+
+        await _sut.CreateAsync(SampleCreateRequest());
+
+        _uow.Verify(u => u.BeginAsync(default), Times.Once);
+        _uow.Verify(u => u.CommitAsync(default), Times.Once);
+    }
+
+    [Fact]
+    public async Task CreateAsync_Rollbacks_OnAddException()
+    {
+        _repo.Setup(r => r.SkuExistsAsync(It.IsAny<string>(), It.IsAny<Guid?>())).ReturnsAsync(false);
+        _repo.Setup(r => r.AddAsync(It.IsAny<Item>())).ThrowsAsync(new Exception("db error"));
+
+        await Assert.ThrowsAsync<Exception>(() => _sut.CreateAsync(SampleCreateRequest()));
+
+        _uow.Verify(u => u.RollbackAsync(default), Times.Once);
+        _uow.Verify(u => u.CommitAsync(default), Times.Never);
+    }
+
+    // UpdateAsync
+
+    [Fact]
+    public async Task UpdateAsync_ReturnsNull_WhenItemNotFound()
+    {
+        _repo.Setup(r => r.GetByIdAsync(It.IsAny<Guid>())).ReturnsAsync((Item?)null);
+
+        var result = await _sut.UpdateAsync(Guid.NewGuid(),
+            new UpdateItemRequest("Name", null, Guid.NewGuid(), null, null, Guid.NewGuid(), null));
+
+        Assert.Null(result);
+        _uow.Verify(u => u.BeginAsync(default), Times.Never);
+    }
+
+    [Fact]
+    public async Task UpdateAsync_ReturnsNull_WhenItemInactive()
+    {
+        _repo.Setup(r => r.GetByIdAsync(It.IsAny<Guid>())).ReturnsAsync(InactiveItem());
+
+        var result = await _sut.UpdateAsync(Guid.NewGuid(),
+            new UpdateItemRequest("Name", null, Guid.NewGuid(), null, null, Guid.NewGuid(), null));
+
+        Assert.Null(result);
+    }
+
+    [Fact]
+    public async Task UpdateAsync_ReturnsNull_WhenItemIsErpSynced()
+    {
+        _repo.Setup(r => r.GetByIdAsync(It.IsAny<Guid>())).ReturnsAsync(ErpItem());
+
+        var result = await _sut.UpdateAsync(Guid.NewGuid(),
+            new UpdateItemRequest("Name", null, Guid.NewGuid(), null, null, Guid.NewGuid(), null));
+
+        Assert.Null(result);
+        _uow.Verify(u => u.BeginAsync(default), Times.Never);
+    }
+
+    [Fact]
+    public async Task UpdateAsync_UpdatesFields_AndCommits()
+    {
+        var item = ManualItem();
+        _repo.Setup(r => r.GetByIdAsync(item.Id)).ReturnsAsync(item);
+        _repo.Setup(r => r.GetByIdAsync(It.IsAny<Guid>())).ReturnsAsync(item);
+
+        var catId = Guid.NewGuid();
+        var uomId = Guid.NewGuid();
+        item.Category = new Category { Name = "Cat" };
+        item.BaseUom = new Uom { Name = "Each" };
+
+        var result = await _sut.UpdateAsync(item.Id,
+            new UpdateItemRequest("Updated", "desc", catId, null, null, uomId, 9.99m));
+
+        _uow.Verify(u => u.BeginAsync(default), Times.Once);
+        _uow.Verify(u => u.CommitAsync(default), Times.Once);
+    }
+
+    // DeleteAsync
+
+    [Fact]
+    public async Task DeleteAsync_ReturnsFalse_WhenItemNotFound()
+    {
+        _repo.Setup(r => r.GetByIdAsync(It.IsAny<Guid>())).ReturnsAsync((Item?)null);
+
+        var result = await _sut.DeleteAsync(Guid.NewGuid());
+
+        Assert.False(result);
+        _uow.Verify(u => u.BeginAsync(default), Times.Never);
+    }
+
+    [Fact]
+    public async Task DeleteAsync_ReturnsFalse_WhenItemInactive()
+    {
+        _repo.Setup(r => r.GetByIdAsync(It.IsAny<Guid>())).ReturnsAsync(InactiveItem());
+
+        var result = await _sut.DeleteAsync(Guid.NewGuid());
+
+        Assert.False(result);
+    }
+
+    [Fact]
+    public async Task DeleteAsync_ReturnsFalse_WhenItemIsErpSynced()
+    {
+        _repo.Setup(r => r.GetByIdAsync(It.IsAny<Guid>())).ReturnsAsync(ErpItem());
+
+        var result = await _sut.DeleteAsync(Guid.NewGuid());
+
+        Assert.False(result);
+        _uow.Verify(u => u.BeginAsync(default), Times.Never);
+    }
+
+    [Fact]
+    public async Task DeleteAsync_CallsRemove_AndCommits_ForManualItem()
+    {
+        var item = ManualItem();
+        _repo.Setup(r => r.GetByIdAsync(item.Id)).ReturnsAsync(item);
+
+        var result = await _sut.DeleteAsync(item.Id);
+
+        Assert.True(result);
+        _repo.Verify(r => r.Remove(item), Times.Once);
+        _uow.Verify(u => u.CommitAsync(default), Times.Once);
+    }
+
+    // ReplaceConversionsAsync
+
+    [Fact]
+    public async Task ReplaceConversionsAsync_ReturnsNull_WhenItemNotFound()
+    {
+        _repo.Setup(r => r.GetByIdAsync(It.IsAny<Guid>())).ReturnsAsync((Item?)null);
+
+        var result = await _sut.ReplaceConversionsAsync(Guid.NewGuid(),
+            new ReplaceConversionsRequest([]));
+
+        Assert.Null(result);
+    }
+
+    [Fact]
+    public async Task ReplaceConversionsAsync_ReturnsNull_WhenItemIsErpSynced()
+    {
+        _repo.Setup(r => r.GetByIdAsync(It.IsAny<Guid>())).ReturnsAsync(ErpItem());
+
+        var result = await _sut.ReplaceConversionsAsync(Guid.NewGuid(),
+            new ReplaceConversionsRequest([]));
+
+        Assert.Null(result);
+        _repo.Verify(r => r.ReplaceConversionsAsync(It.IsAny<Guid>(), It.IsAny<List<UomConversion>>()), Times.Never);
+    }
+
+    [Fact]
+    public async Task ReplaceConversionsAsync_CallsReplace_AndCommits()
+    {
+        var item = ManualItem();
+        _repo.Setup(r => r.GetByIdAsync(item.Id)).ReturnsAsync(item);
+        _repo.Setup(r => r.ReplaceConversionsAsync(It.IsAny<Guid>(), It.IsAny<List<UomConversion>>()))
+            .Returns(Task.CompletedTask);
+        _repo.Setup(r => r.GetByIdAsync(It.IsAny<Guid>())).ReturnsAsync(item);
+
+        await _sut.ReplaceConversionsAsync(item.Id, new ReplaceConversionsRequest([]));
+
+        _repo.Verify(r => r.ReplaceConversionsAsync(item.Id, It.IsAny<List<UomConversion>>()), Times.Once);
+        _uow.Verify(u => u.CommitAsync(default), Times.Once);
+    }
+}

Distribution.Tests/Services/NotificationServiceTests.cs

@@ -0,0 +1,209 @@
+using Distribution.Features.Notifications;
+using Distribution.Infra.UoW;
+using Microsoft.AspNetCore.SignalR;
+using Microsoft.Extensions.Logging.Abstractions;
+using Moq;
+using Xunit;
+
+namespace Distribution.Tests.Services;
+
+public class NotificationServiceTests
+{
+    private readonly Mock<INotificationRepository> _repo = new();
+    private readonly Mock<IUnitOfWork> _uow = new();
+    private readonly Mock<IHubContext<NotificationHub>> _hub = new();
+    private readonly Mock<IHubClients> _clients = new();
+    private readonly Mock<IClientProxy> _proxy = new();
+    private readonly NotificationService _sut;
+
+    public NotificationServiceTests()
+    {
+        _repo.Setup(r => r.FilterActiveUserIdsAsync(It.IsAny<IEnumerable<Guid>>()))
+            .ReturnsAsync((IEnumerable<Guid> ids) => ids.ToList());
+        _hub.SetupGet(h => h.Clients).Returns(_clients.Object);
+        _clients.Setup(c => c.User(It.IsAny<string>())).Returns(_proxy.Object);
+
+        _sut = new NotificationService(
+            _repo.Object,
+            new NotificationRecipientResolver(_repo.Object),
+            _hub.Object,
+            _uow.Object,
+            NullLogger<NotificationService>.Instance);
+    }
+
+    private static NotificationArgs Args(Guid? actor = null) =>
+        new(new { StoreName = "Fort Mini Mart" }, "DeliveryTask", Guid.NewGuid(), "/operations/delivery-tasks/1", actor);
+
+    // Registry
+
+    [Fact]
+    public void EveryNotificationTypeConstant_HasADefinition()
+    {
+        var constants = typeof(NotificationTypes)
+            .GetFields()
+            .Where(f => f.IsLiteral && f.FieldType == typeof(string))
+            .Select(f => (string)f.GetRawConstantValue()!)
+            .ToList();
+
+        Assert.NotEmpty(constants);
+        Assert.Equal(constants.Count, constants.Distinct().Count());
+        Assert.All(constants, c => Assert.True(NotificationTypes.All.ContainsKey(c), $"{c} has no definition"));
+    }
+
+    // NotifyAsync
+
+    [Fact]
+    public async Task NotifyAsync_DoesNothing_WhenTypeIsNotRegistered()
+    {
+        await _sut.NotifyAsync("NotARealType", [RecipientRule.Users(Guid.NewGuid())], Args());
+
+        _repo.Verify(r => r.AddAsync(It.IsAny<Models.Notification>()), Times.Never);
+        _uow.Verify(u => u.CommitAsync(It.IsAny<CancellationToken>()), Times.Never);
+    }
+
+    [Fact]
+    public async Task NotifyAsync_DoesNothing_WhenThereAreNoRecipients()
+    {
+        await _sut.NotifyAsync(NotificationTypes.DeliveryTaskFailed, [RecipientRule.Users()], Args());
+
+        _repo.Verify(r => r.AddAsync(It.IsAny<Models.Notification>()), Times.Never);
+    }
+
+    [Fact]
+    public async Task NotifyAsync_ExcludesTheActingUser()
+    {
+        var actor = Guid.NewGuid();
+        var other = Guid.NewGuid();
+        Models.Notification? saved = null;
+        _repo.Setup(r => r.AddAsync(It.IsAny<Models.Notification>()))
+            .Callback<Models.Notification>(n => saved = n)
+            .Returns(Task.CompletedTask);
+
+        await _sut.NotifyAsync(NotificationTypes.DeliveryTaskFailed,
+            [RecipientRule.Users(actor, other)], Args(actor));
+
+        Assert.NotNull(saved);
+        var recipient = Assert.Single(saved!.Recipients);
+        Assert.Equal(other, recipient.FK_UserId);
+    }
+
+    [Fact]
+    public async Task NotifyAsync_RendersTemplate_CommitsAndPushesToEachRecipient()
+    {
+        var a = Guid.NewGuid();
+        var b = Guid.NewGuid();
+        Models.Notification? saved = null;
+        _repo.Setup(r => r.AddAsync(It.IsAny<Models.Notification>()))
+            .Callback<Models.Notification>(n => saved = n)
+            .Returns(Task.CompletedTask);
+
+        await _sut.NotifyAsync(NotificationTypes.DeliveryTaskFailed, [RecipientRule.Users(a, b)], Args());
+
+        Assert.Equal("Delivery to Fort Mini Mart failed.", saved!.Message);
+        Assert.Equal(Models.NotificationSeverity.Warning, saved.Severity);
+        _uow.Verify(u => u.CommitAsync(It.IsAny<CancellationToken>()), Times.Once);
+        _clients.Verify(c => c.User(a.ToString()), Times.Once);
+        _clients.Verify(c => c.User(b.ToString()), Times.Once);
+        _proxy.Verify(p => p.SendCoreAsync(NotificationHub.ClientEvent,
+            It.IsAny<object?[]>(), It.IsAny<CancellationToken>()), Times.Exactly(2));
+    }
+
+    [Fact]
+    public async Task NotifyAsync_DoesNotThrow_WhenSavingFails_AndDiscardsTheEntity()
+    {
+        _uow.Setup(u => u.CommitAsync(It.IsAny<CancellationToken>())).ThrowsAsync(new InvalidOperationException("db down"));
+
+        var ex = await Record.ExceptionAsync(() =>
+            _sut.NotifyAsync(NotificationTypes.DeliveryTaskFailed, [RecipientRule.Users(Guid.NewGuid())], Args()));
+
+        Assert.Null(ex);
+        _repo.Verify(r => r.Discard(It.IsAny<Models.Notification>()), Times.Once);
+        _proxy.Verify(p => p.SendCoreAsync(It.IsAny<string>(), It.IsAny<object?[]>(), It.IsAny<CancellationToken>()), Times.Never);
+    }
+
+    [Fact]
+    public async Task NotifyAsync_DoesNotThrow_WhenPushFails_AndKeepsTheSavedNotification()
+    {
+        _proxy.Setup(p => p.SendCoreAsync(It.IsAny<string>(), It.IsAny<object?[]>(), It.IsAny<CancellationToken>()))
+            .ThrowsAsync(new InvalidOperationException("socket gone"));
+
+        var ex = await Record.ExceptionAsync(() =>
+            _sut.NotifyAsync(NotificationTypes.DeliveryTaskFailed, [RecipientRule.Users(Guid.NewGuid())], Args()));
+
+        Assert.Null(ex);
+        _uow.Verify(u => u.CommitAsync(It.IsAny<CancellationToken>()), Times.Once);
+        _repo.Verify(r => r.Discard(It.IsAny<Models.Notification>()), Times.Never);
+    }
+
+    // Recipient rules
+
+    [Fact]
+    public async Task PermissionInScope_ResolvesToTheIntersectionOfPermissionAndScope()
+    {
+        var both = Guid.NewGuid();
+        var permissionOnly = Guid.NewGuid();
+        var scopeOnly = Guid.NewGuid();
+        var storeId = Guid.NewGuid();
+        _repo.Setup(r => r.GetUserIdsByPermissionAsync("store.manage")).ReturnsAsync([both, permissionOnly]);
+        _repo.Setup(r => r.GetUserIdsByScopeAsync(ScopeKind.Store, storeId)).ReturnsAsync([both, scopeOnly]);
+
+        var ids = await new NotificationRecipientResolver(_repo.Object)
+            .ResolveAsync([RecipientRule.PermissionInScope("store.manage", ScopeKind.Store, storeId)], actingUserId: null);
+
+        Assert.Equal([both], ids);
+    }
+
+    [Fact]
+    public async Task ReportsTo_ResolvesToTheSupervisor_AndIsEmptyWhenThereIsNone()
+    {
+        var user = Guid.NewGuid();
+        var supervisor = Guid.NewGuid();
+        var resolver = new NotificationRecipientResolver(_repo.Object);
+
+        _repo.Setup(r => r.GetReportsToUserIdAsync(user)).ReturnsAsync(supervisor);
+        Assert.Equal([supervisor], await resolver.ResolveAsync([RecipientRule.ReportsTo(user)], null));
+
+        _repo.Setup(r => r.GetReportsToUserIdAsync(user)).ReturnsAsync((Guid?)null);
+        Assert.Empty(await resolver.ResolveAsync([RecipientRule.ReportsTo(user)], null));
+    }
+
+    [Fact]
+    public async Task RouteOwner_ResolvesToTheOwner_AndIsEmptyWhenTheRouteHasNone()
+    {
+        var storeId = Guid.NewGuid();
+        var owner = Guid.NewGuid();
+        var resolver = new NotificationRecipientResolver(_repo.Object);
+
+        _repo.Setup(r => r.GetRouteOwnerUserIdAsync(ScopeKind.Store, storeId)).ReturnsAsync(owner);
+        Assert.Equal([owner], await resolver.ResolveAsync([RecipientRule.RouteOwner(ScopeKind.Store, storeId)], null));
+
+        _repo.Setup(r => r.GetRouteOwnerUserIdAsync(ScopeKind.Store, storeId)).ReturnsAsync((Guid?)null);
+        Assert.Empty(await resolver.ResolveAsync([RecipientRule.RouteOwner(ScopeKind.Store, storeId)], null));
+    }
+
+    [Fact]
+    public async Task OptionalTokenAtTheEndOfATemplate_LeavesNoTrailingSpace()
+    {
+        Models.Notification? saved = null;
+        _repo.Setup(r => r.AddAsync(It.IsAny<Models.Notification>()))
+            .Callback<Models.Notification>(n => saved = n)
+            .Returns(Task.CompletedTask);
+
+        await _sut.NotifyAsync(NotificationTypes.DeliveryTaskFailed, [RecipientRule.Users(Guid.NewGuid())],
+            new NotificationArgs(new { StoreName = "Fort Mini Mart", Note = (string?)null }, "DeliveryTask", Guid.NewGuid(), "/x"));
+
+        Assert.Equal("Delivery to Fort Mini Mart failed.", saved!.Message);
+    }
+
+    [Fact]
+    public async Task Resolve_DeduplicatesUsersAcrossRules()
+    {
+        var user = Guid.NewGuid();
+        _repo.Setup(r => r.GetUserIdsByPermissionAsync("stock.manage")).ReturnsAsync([user]);
+
+        var ids = await new NotificationRecipientResolver(_repo.Object)
+            .ResolveAsync([RecipientRule.Users(user), RecipientRule.Permission("stock.manage")], null);
+
+        Assert.Equal([user], ids);
+    }
+}

Distribution.Tests/Services/OrderServiceTests.cs

@@ -0,0 +1,229 @@
+using Distribution.Features.Order;
+using Distribution.Infra.Authorization;
+using Distribution.Infra.UoW;
+using Distribution.Models;
+using Moq;
+using Xunit;
+
+namespace Distribution.Tests.Services;
+
+public class OrderServiceTests
+{
+    private readonly Mock<IOrderRepository> _repo = new();
+    private readonly Mock<IUnitOfWork> _uow = new();
+    private readonly Mock<ICurrentUserService> _currentUser = new();
+    private readonly Mock<IScopeAccessService> _scopeAccess = new();
+    private readonly OrderService _sut;
+
+    public OrderServiceTests()
+    {
+        _sut = new OrderService(_repo.Object, _uow.Object, _currentUser.Object, _scopeAccess.Object);
+    }
+
+    private static Order ActiveOrder(Guid storeId) => new()
+    {
+        Id = Guid.NewGuid(),
+        FK_StoreId = storeId,
+        OrderDate = DateTime.Now,
+        TotalAmount = 100,
+        IsActive = true
+    };
+
+    private void SetupGlobalUser(Guid userId)
+    {
+        _currentUser.Setup(u => u.UserId).Returns(userId);
+        _currentUser.Setup(u => u.RoleLevel).Returns(50);
+    }
+
+    private void SetupScopedUser(Guid userId)
+    {
+        _currentUser.Setup(u => u.UserId).Returns(userId);
+        _currentUser.Setup(u => u.RoleLevel).Returns(10);
+    }
+
+    // GetAllAsync
+
+    [Fact]
+    public async Task GetAllAsync_GlobalUser_ReturnsAllActiveOrders()
+    {
+        var userId = Guid.NewGuid();
+        var storeA = Guid.NewGuid();
+        var storeB = Guid.NewGuid();
+        SetupGlobalUser(userId);
+        var orders = new List<Order> { ActiveOrder(storeA), ActiveOrder(storeB) };
+        _repo.Setup(r => r.GetAllAsync()).ReturnsAsync(orders);
+        _repo.Setup(r => r.GetItemsByOrderIdAsync(It.IsAny<Guid>())).ReturnsAsync([]);
+
+        var result = await _sut.GetAllAsync();
+
+        Assert.Equal(2, result.Count);
+    }
+
+    [Fact]
+    public async Task GetAllAsync_ScopedUser_FiltersToAccessibleStores()
+    {
+        var userId = Guid.NewGuid();
+        var accessibleStore = Guid.NewGuid();
+        var restrictedStore = Guid.NewGuid();
+        SetupScopedUser(userId);
+        _scopeAccess.Setup(s => s.GetAccessibleStoreIdsAsync(userId)).ReturnsAsync([accessibleStore]);
+        var orders = new List<Order> { ActiveOrder(accessibleStore), ActiveOrder(restrictedStore) };
+        _repo.Setup(r => r.GetAllAsync()).ReturnsAsync(orders);
+        _repo.Setup(r => r.GetItemsByOrderIdAsync(It.IsAny<Guid>())).ReturnsAsync([]);
+
+        var result = await _sut.GetAllAsync();
+
+        Assert.Single(result);
+        Assert.Equal(accessibleStore, result[0].StoreId);
+    }
+
+    [Fact]
+    public async Task GetAllAsync_FiltersOutInactiveOrders()
+    {
+        var userId = Guid.NewGuid();
+        SetupGlobalUser(userId);
+        var inactiveOrder = ActiveOrder(Guid.NewGuid());
+        inactiveOrder.IsActive = false;
+        _repo.Setup(r => r.GetAllAsync()).ReturnsAsync([inactiveOrder]);
+        _repo.Setup(r => r.GetItemsByOrderIdAsync(It.IsAny<Guid>())).ReturnsAsync([]);
+
+        var result = await _sut.GetAllAsync();
+
+        Assert.Empty(result);
+    }
+
+    // GetByIdAsync
+
+    [Fact]
+    public async Task GetByIdAsync_ReturnsNull_WhenOrderNotFound()
+    {
+        SetupGlobalUser(Guid.NewGuid());
+        _repo.Setup(r => r.GetByIdAsync(It.IsAny<Guid>())).ReturnsAsync((Order?)null);
+
+        var result = await _sut.GetByIdAsync(Guid.NewGuid());
+
+        Assert.Null(result);
+    }
+
+    [Fact]
+    public async Task GetByIdAsync_ReturnsNull_WhenUserLacksStoreScope()
+    {
+        var userId = Guid.NewGuid();
+        var storeId = Guid.NewGuid();
+        SetupScopedUser(userId);
+        _repo.Setup(r => r.GetByIdAsync(It.IsAny<Guid>())).ReturnsAsync(ActiveOrder(storeId));
+        _scopeAccess.Setup(s => s.HasStoreScopeAsync(userId, storeId)).ReturnsAsync(false);
+
+        var result = await _sut.GetByIdAsync(Guid.NewGuid());
+
+        Assert.Null(result);
+    }
+
+    [Fact]
+    public async Task GetByIdAsync_ReturnsOrder_WhenGlobalUser()
+    {
+        var userId = Guid.NewGuid();
+        var order = ActiveOrder(Guid.NewGuid());
+        SetupGlobalUser(userId);
+        _repo.Setup(r => r.GetByIdAsync(order.Id)).ReturnsAsync(order);
+        _repo.Setup(r => r.GetItemsByOrderIdAsync(order.Id)).ReturnsAsync([]);
+
+        var result = await _sut.GetByIdAsync(order.Id);
+
+        Assert.NotNull(result);
+        Assert.Equal(order.Id, result.Id);
+    }
+
+    // CreateAsync
+
+    [Fact]
+    public async Task CreateAsync_ReturnsNull_WhenUserLacksStoreScope()
+    {
+        var userId = Guid.NewGuid();
+        var storeId = Guid.NewGuid();
+        SetupScopedUser(userId);
+        _scopeAccess.Setup(s => s.HasStoreScopeAsync(userId, storeId)).ReturnsAsync(false);
+
+        var result = await _sut.CreateAsync(
+            new CreateOrderRequest(storeId, DateTime.Now, 100, []));
+
+        Assert.Null(result);
+        _uow.Verify(u => u.BeginAsync(default), Times.Never);
+    }
+
+    [Fact]
+    public async Task CreateAsync_CreatesOrder_WhenGlobalUser()
+    {
+        var userId = Guid.NewGuid();
+        var storeId = Guid.NewGuid();
+        SetupGlobalUser(userId);
+        _repo.Setup(r => r.AddAsync(It.IsAny<Order>())).Returns(Task.CompletedTask);
+        _repo.Setup(r => r.AddItemsAsync(It.IsAny<IEnumerable<OrderItem>>())).Returns(Task.CompletedTask);
+
+        var result = await _sut.CreateAsync(
+            new CreateOrderRequest(storeId, DateTime.Now, 250, []));
+
+        Assert.NotNull(result);
+        Assert.Equal(storeId, result.StoreId);
+        Assert.Equal(250, result.TotalAmount);
+        _uow.Verify(u => u.BeginAsync(default), Times.Once);
+        _uow.Verify(u => u.CommitAsync(default), Times.Once);
+    }
+
+    [Fact]
+    public async Task CreateAsync_Rollbacks_OnException()
+    {
+        var userId = Guid.NewGuid();
+        SetupGlobalUser(userId);
+        _repo.Setup(r => r.AddAsync(It.IsAny<Order>())).ThrowsAsync(new Exception("db error"));
+
+        await Assert.ThrowsAsync<Exception>(() =>
+            _sut.CreateAsync(new CreateOrderRequest(Guid.NewGuid(), DateTime.Now, 100, [])));
+
+        _uow.Verify(u => u.RollbackAsync(default), Times.Once);
+        _uow.Verify(u => u.CommitAsync(default), Times.Never);
+    }
+
+    // DeleteAsync
+
+    [Fact]
+    public async Task DeleteAsync_ReturnsFalse_WhenOrderNotFound()
+    {
+        SetupGlobalUser(Guid.NewGuid());
+        _repo.Setup(r => r.GetByIdAsync(It.IsAny<Guid>())).ReturnsAsync((Order?)null);
+
+        var result = await _sut.DeleteAsync(Guid.NewGuid());
+
+        Assert.False(result);
+    }
+
+    [Fact]
+    public async Task DeleteAsync_ReturnsFalse_WhenUserLacksStoreScope()
+    {
+        var userId = Guid.NewGuid();
+        var storeId = Guid.NewGuid();
+        SetupScopedUser(userId);
+        _repo.Setup(r => r.GetByIdAsync(It.IsAny<Guid>())).ReturnsAsync(ActiveOrder(storeId));
+        _scopeAccess.Setup(s => s.HasStoreScopeAsync(userId, storeId)).ReturnsAsync(false);
+
+        var result = await _sut.DeleteAsync(Guid.NewGuid());
+
+        Assert.False(result);
+        _uow.Verify(u => u.BeginAsync(default), Times.Never);
+    }
+
+    [Fact]
+    public async Task DeleteAsync_RemovesOrder_WhenAuthorized()
+    {
+        var userId = Guid.NewGuid();
+        var order = ActiveOrder(Guid.NewGuid());
+        SetupGlobalUser(userId);
+        _repo.Setup(r => r.GetByIdAsync(order.Id)).ReturnsAsync(order);
+
+        var result = await _sut.DeleteAsync(order.Id);
+
+        Assert.True(result);
+        _repo.Verify(r => r.Remove(order), Times.Once);
+        _uow.Verify(u => u.CommitAsync(default), Times.Once);
+    }
+}

Distribution.Tests/Services/RegionServiceTests.cs

@@ -0,0 +1,405 @@
+using Distribution.Features.Region;
+using Distribution.Infra.Authorization;
+using Distribution.Infra.UoW;
+using Distribution.Models;
+using Moq;
+using Xunit;
+
+namespace Distribution.Tests.Services;
+
+public class RegionServiceTests
+{
+    private readonly Mock<IRegionRepository> _repo = new();
+    private readonly Mock<IUnitOfWork> _uow = new();
+    private readonly Mock<ICurrentUserService> _currentUser = new();
+    private readonly Mock<IScopeAccessService> _scopeAccess = new();
+    private readonly RegionService _sut;
+
+    public RegionServiceTests()
+    {
+        _currentUser.Setup(u => u.RoleLevel).Returns(60);
+        _repo.Setup(r => r.GetAllCodesAsync()).ReturnsAsync([]);
+        _sut = new RegionService(_repo.Object, _uow.Object, _currentUser.Object, _scopeAccess.Object);
+    }
+
+    private static Region ActiveRegion(string name = "North") =>
+        new() { Id = Guid.NewGuid(), Name = name, IsActive = true };
+
+    private static Region InactiveRegion() =>
+        new() { Id = Guid.NewGuid(), Name = "Old", IsActive = false };
+
+    // GetAllAsync
+
+    [Fact]
+    public async Task GetAllAsync_ReturnsOnlyActiveRegions()
+    {
+        _repo.Setup(r => r.GetAllAsync()).ReturnsAsync([ActiveRegion(), InactiveRegion()]);
+
+        var result = await _sut.GetAllAsync();
+
+        Assert.Single(result);
+        Assert.True(result[0].IsActive);
+    }
+
+    [Fact]
+    public async Task GetAllAsync_ReturnsEmpty_WhenNoneActive()
+    {
+        _repo.Setup(r => r.GetAllAsync()).ReturnsAsync([InactiveRegion()]);
+
+        var result = await _sut.GetAllAsync();
+
+        Assert.Empty(result);
+    }
+
+    // GetByIdAsync
+
+    [Fact]
+    public async Task GetByIdAsync_ReturnsNull_WhenNotFound()
+    {
+        _repo.Setup(r => r.GetByIdAsync(It.IsAny<Guid>())).ReturnsAsync((Region?)null);
+
+        var result = await _sut.GetByIdAsync(Guid.NewGuid());
+
+        Assert.Null(result);
+    }
+
+    [Fact]
+    public async Task GetByIdAsync_ReturnsNull_WhenInactive()
+    {
+        _repo.Setup(r => r.GetByIdAsync(It.IsAny<Guid>())).ReturnsAsync(InactiveRegion());
+
+        var result = await _sut.GetByIdAsync(Guid.NewGuid());
+
+        Assert.Null(result);
+    }
+
+    [Fact]
+    public async Task GetByIdAsync_ReturnsResponse_WhenActiveRegionFound()
+    {
+        var region = ActiveRegion("South");
+        _repo.Setup(r => r.GetByIdAsync(region.Id)).ReturnsAsync(region);
+
+        var result = await _sut.GetByIdAsync(region.Id);
+
+        Assert.NotNull(result);
+        Assert.Equal("South", result.Name);
+        Assert.Equal(region.Id, result.Id);
+    }
+
+    // CreateAsync
+
+    [Fact]
+    public async Task CreateAsync_AddsRegion_AndCommits()
+    {
+        var request = new CreateRegionRequest("East");
+
+        var result = await _sut.CreateAsync(request);
+
+        _uow.Verify(u => u.BeginAsync(default), Times.Once);
+        _repo.Verify(r => r.AddAsync(It.Is<Region>(x => x.Name == "East")), Times.Once);
+        _uow.Verify(u => u.CommitAsync(default), Times.Once);
+        Assert.Equal("East", result.Name);
+    }
+
+    [Fact]
+    public async Task CreateAsync_Rollbacks_WhenAddThrows()
+    {
+        _repo.Setup(r => r.AddAsync(It.IsAny<Region>())).ThrowsAsync(new Exception("db error"));
+
+        await Assert.ThrowsAsync<Exception>(() => _sut.CreateAsync(new CreateRegionRequest("X")));
+
+        _uow.Verify(u => u.RollbackAsync(default), Times.Once);
+        _uow.Verify(u => u.CommitAsync(default), Times.Never);
+    }
+
+    // UpdateAsync
+
+    [Fact]
+    public async Task UpdateAsync_ReturnsNull_WhenNotFound()
+    {
+        _repo.Setup(r => r.GetByIdAsync(It.IsAny<Guid>())).ReturnsAsync((Region?)null);
+
+        var result = await _sut.UpdateAsync(Guid.NewGuid(), new UpdateRegionRequest("New"));
+
+        Assert.Null(result);
+        _uow.Verify(u => u.BeginAsync(default), Times.Never);
+    }
+
+    [Fact]
+    public async Task UpdateAsync_ReturnsNull_WhenInactive()
+    {
+        _repo.Setup(r => r.GetByIdAsync(It.IsAny<Guid>())).ReturnsAsync(InactiveRegion());
+
+        var result = await _sut.UpdateAsync(Guid.NewGuid(), new UpdateRegionRequest("New"));
+
+        Assert.Null(result);
+    }
+
+    [Fact]
+    public async Task UpdateAsync_UpdatesName_AndCommits()
+    {
+        var region = ActiveRegion("Old Name");
+        _repo.Setup(r => r.GetByIdAsync(region.Id)).ReturnsAsync(region);
+
+        var result = await _sut.UpdateAsync(region.Id, new UpdateRegionRequest("New Name"));
+
+        Assert.NotNull(result);
+        Assert.Equal("New Name", result.Name);
+        _uow.Verify(u => u.BeginAsync(default), Times.Once);
+        _uow.Verify(u => u.CommitAsync(default), Times.Once);
+    }
+
+    // Region code
+
+    [Fact]
+    public async Task CreateAsync_GeneratesFirstCode_WhenNoRegionsExist()
+    {
+        _repo.Setup(r => r.GetAllCodesAsync()).ReturnsAsync([]);
+
+        var result = await _sut.CreateAsync(new CreateRegionRequest("North"));
+
+        Assert.Equal("REG-0001", result.Code);
+    }
+
+    [Fact]
+    public async Task CreateAsync_GeneratesNextCode_FromHighestExisting_IgnoringNonMatching()
+    {
+        _repo.Setup(r => r.GetAllCodesAsync()).ReturnsAsync(["REG-0002", "REG-0009", "CUSTOM", "REG-abc", ""]);
+
+        var result = await _sut.CreateAsync(new CreateRegionRequest("North"));
+
+        Assert.Equal("REG-0010", result.Code);
+    }
+
+    [Fact]
+    public async Task CreateAsync_StoresProvidedCode_AsEntered()
+    {
+        var result = await _sut.CreateAsync(new CreateRegionRequest("North", " nth-1 "));
+
+        Assert.Equal("nth-1", result.Code);
+        _repo.Verify(r => r.GetAllCodesAsync(), Times.Never);
+    }
+
+    [Fact]
+    public async Task CreateAsync_Throws_WhenProvidedCodeInUse()
+    {
+        _repo.Setup(r => r.CodeExistsAsync("NTH-1", null)).ReturnsAsync(true);
+
+        await Assert.ThrowsAsync<InvalidOperationException>(() =>
+            _sut.CreateAsync(new CreateRegionRequest("North", "NTH-1")));
+
+        _uow.Verify(u => u.CommitAsync(default), Times.Never);
+    }
+
+    [Fact]
+    public async Task GetNextCodeAsync_ReturnsSuggestion()
+    {
+        _repo.Setup(r => r.GetAllCodesAsync()).ReturnsAsync(["REG-0003"]);
+
+        var result = await _sut.GetNextCodeAsync();
+
+        Assert.Equal("REG-0004", result.Code);
+    }
+
+    [Fact]
+    public async Task UpdateAsync_ChangesCode_StoredAsEntered()
+    {
+        var region = ActiveRegion();
+        region.Code = "REG-0001";
+        _repo.Setup(r => r.GetByIdAsync(region.Id)).ReturnsAsync(region);
+        _repo.Setup(r => r.CodeExistsAsync("north-1", region.Id)).ReturnsAsync(false);
+
+        var result = await _sut.UpdateAsync(region.Id, new UpdateRegionRequest("North", " north-1 "));
+
+        Assert.Equal("north-1", result!.Code);
+        _uow.Verify(u => u.CommitAsync(default), Times.Once);
+    }
+
+    [Fact]
+    public async Task UpdateAsync_KeepsCode_WhenCodeBlank()
+    {
+        var region = ActiveRegion();
+        region.Code = "REG-0001";
+        _repo.Setup(r => r.GetByIdAsync(region.Id)).ReturnsAsync(region);
+
+        var result = await _sut.UpdateAsync(region.Id, new UpdateRegionRequest("North", "  "));
+
+        Assert.Equal("REG-0001", result!.Code);
+        _repo.Verify(r => r.CodeExistsAsync(It.IsAny<string>(), It.IsAny<Guid?>()), Times.Never);
+    }
+
+    [Fact]
+    public async Task UpdateAsync_Throws_WhenCodeUsedByAnotherRegion()
+    {
+        var region = ActiveRegion();
+        region.Code = "REG-0001";
+        _repo.Setup(r => r.GetByIdAsync(region.Id)).ReturnsAsync(region);
+        _repo.Setup(r => r.CodeExistsAsync("REG-0002", region.Id)).ReturnsAsync(true);
+
+        await Assert.ThrowsAsync<InvalidOperationException>(() =>
+            _sut.UpdateAsync(region.Id, new UpdateRegionRequest("North", "REG-0002")));
+
+        _uow.Verify(u => u.CommitAsync(default), Times.Never);
+    }
+
+    [Fact]
+    public async Task UpdateAsync_AllowsResubmittingOwnCode()
+    {
+        var region = ActiveRegion();
+        region.Code = "REG-0001";
+        _repo.Setup(r => r.GetByIdAsync(region.Id)).ReturnsAsync(region);
+
+        var result = await _sut.UpdateAsync(region.Id, new UpdateRegionRequest("North", "REG-0001"));
+
+        Assert.Equal("REG-0001", result!.Code);
+    }
+
+    [Fact]
+    public async Task GetByIdAsync_ReturnsCode()
+    {
+        var region = ActiveRegion();
+        region.Code = "REG-0007";
+        _repo.Setup(r => r.GetByIdAsync(region.Id)).ReturnsAsync(region);
+
+        var result = await _sut.GetByIdAsync(region.Id);
+
+        Assert.Equal("REG-0007", result!.Code);
+    }
+
+    // DeleteAsync
+
+    [Fact]
+    public async Task DeleteAsync_ReturnsFalse_WhenNotFound()
+    {
+        _repo.Setup(r => r.GetByIdAsync(It.IsAny<Guid>())).ReturnsAsync((Region?)null);
+
+        var result = await _sut.DeleteAsync(Guid.NewGuid());
+
+        Assert.False(result);
+        _uow.Verify(u => u.BeginAsync(default), Times.Never);
+    }
+
+    [Fact]
+    public async Task DeleteAsync_ReturnsFalse_WhenInactive()
+    {
+        _repo.Setup(r => r.GetByIdAsync(It.IsAny<Guid>())).ReturnsAsync(InactiveRegion());
+
+        var result = await _sut.DeleteAsync(Guid.NewGuid());
+
+        Assert.False(result);
+    }
+
+    [Fact]
+    public async Task DeleteAsync_CallsRemove_AndCommits()
+    {
+        var region = ActiveRegion();
+        _repo.Setup(r => r.GetByIdAsync(region.Id)).ReturnsAsync(region);
+
+        var result = await _sut.DeleteAsync(region.Id);
+
+        Assert.True(result);
+        _repo.Verify(r => r.Remove(region), Times.Once);
+        _uow.Verify(u => u.CommitAsync(default), Times.Once);
+    }
+
+    [Fact]
+    public async Task DeleteAsync_Rollbacks_WhenRemoveThrows()
+    {
+        var region = ActiveRegion();
+        _repo.Setup(r => r.GetByIdAsync(region.Id)).ReturnsAsync(region);
+        _repo.Setup(r => r.Remove(It.IsAny<Region>())).Throws(new Exception("db error"));
+
+        await Assert.ThrowsAsync<Exception>(() => _sut.DeleteAsync(region.Id));
+
+        _uow.Verify(u => u.RollbackAsync(default), Times.Once);
+    }
+
+    // Region manager
+
+    private static User ManagerUser(string role = "RegionalManager", bool active = true) => new()
+    {
+        Id = Guid.NewGuid(), Username = "mgr", FullName = "Mgr One", IsActive = active,
+        Role = new Role { Name = role, Level = 50 }
+    };
+
+    [Fact]
+    public async Task SetManagerAsync_ReturnsNull_WhenRegionMissing()
+    {
+        _repo.Setup(r => r.GetByIdAsync(It.IsAny<Guid>())).ReturnsAsync((Region?)null);
+
+        Assert.Null(await _sut.SetManagerAsync(Guid.NewGuid(), new SetRegionManagerRequest(Guid.NewGuid())));
+    }
+
+    [Fact]
+    public async Task SetManagerAsync_Throws_WhenUserNotRegionalManager()
+    {
+        var region = ActiveRegion();
+        var user = ManagerUser("SalesRep");
+        _repo.Setup(r => r.GetByIdAsync(region.Id)).ReturnsAsync(region);
+        _repo.Setup(r => r.GetUserWithRoleAsync(user.Id)).ReturnsAsync(user);
+
+        await Assert.ThrowsAsync<InvalidOperationException>(() =>
+            _sut.SetManagerAsync(region.Id, new SetRegionManagerRequest(user.Id)));
+        _uow.Verify(u => u.CommitAsync(default), Times.Never);
+    }
+
+    [Fact]
+    public async Task SetManagerAsync_ReplacesExistingManager_AndAddsScope()
+    {
+        var region = ActiveRegion();
+        var user = ManagerUser();
+        var old = new UserRegionScope { FK_UserId = Guid.NewGuid(), FK_RegionId = region.Id };
+        _repo.Setup(r => r.GetByIdAsync(region.Id)).ReturnsAsync(region);
+        _repo.Setup(r => r.GetUserWithRoleAsync(user.Id)).ReturnsAsync(user);
+        _repo.Setup(r => r.GetManagerScopesAsync(region.Id)).ReturnsAsync([old]);
+        _repo.Setup(r => r.GetRegionScopeAsync(user.Id, region.Id)).ReturnsAsync((UserRegionScope?)null);
+
+        var result = await _sut.SetManagerAsync(region.Id, new SetRegionManagerRequest(user.Id));
+
+        Assert.Equal(user.Id, result!.UserId);
+        _repo.Verify(r => r.RemoveRegionScopes(It.Is<IEnumerable<UserRegionScope>>(s => s.Single() == old)), Times.Once);
+        _repo.Verify(r => r.AddRegionScopeAsync(It.Is<UserRegionScope>(s => s.FK_UserId == user.Id && s.FK_RegionId == region.Id)), Times.Once);
+        _uow.Verify(u => u.CommitAsync(default), Times.Once);
+    }
+
+    [Fact]
+    public async Task SetManagerAsync_DoesNotDuplicateScope_WhenAlreadyManager()
+    {
+        var region = ActiveRegion();
+        var user = ManagerUser();
+        var existing = new UserRegionScope { FK_UserId = user.Id, FK_RegionId = region.Id };
+        _repo.Setup(r => r.GetByIdAsync(region.Id)).ReturnsAsync(region);
+        _repo.Setup(r => r.GetUserWithRoleAsync(user.Id)).ReturnsAsync(user);
+        _repo.Setup(r => r.GetManagerScopesAsync(region.Id)).ReturnsAsync([existing]);
+        _repo.Setup(r => r.GetRegionScopeAsync(user.Id, region.Id)).ReturnsAsync(existing);
+
+        await _sut.SetManagerAsync(region.Id, new SetRegionManagerRequest(user.Id));
+
+        _repo.Verify(r => r.AddRegionScopeAsync(It.IsAny<UserRegionScope>()), Times.Never);
+        _repo.Verify(r => r.RemoveRegionScopes(It.Is<IEnumerable<UserRegionScope>>(s => !s.Any())), Times.Once);
+    }
+
+    [Fact]
+    public async Task RemoveManagerAsync_ReturnsFalse_WhenNoManager()
+    {
+        var region = ActiveRegion();
+        _repo.Setup(r => r.GetByIdAsync(region.Id)).ReturnsAsync(region);
+        _repo.Setup(r => r.GetManagerScopesAsync(region.Id)).ReturnsAsync([]);
+
+        Assert.False(await _sut.RemoveManagerAsync(region.Id));
+    }
+
+    [Fact]
+    public async Task GetManagerAsync_ReturnsManager()
+    {
+        var region = ActiveRegion();
+        var user = ManagerUser();
+        _repo.Setup(r => r.GetByIdAsync(region.Id)).ReturnsAsync(region);
+        _repo.Setup(r => r.GetManagerScopesAsync(region.Id))
+            .ReturnsAsync([new UserRegionScope { FK_UserId = user.Id, FK_RegionId = region.Id, User = user }]);
+
+        var result = await _sut.GetManagerAsync(region.Id);
+
+        Assert.Equal("mgr", result!.Username);
+    }
+}

Distribution.Tests/Services/RouteServiceTests.cs

@@ -0,0 +1,343 @@
+using Distribution.Features.Region;
+using Distribution.Features.Route;
+using Distribution.Infra.Authorization;
+using Distribution.Infra.UoW;
+using Distribution.Models;
+using Moq;
+using Xunit;
+
+namespace Distribution.Tests.Services;
+
+public class RouteServiceTests
+{
+    private readonly Mock<IRouteRepository> _repo = new();
+    private readonly Mock<IRegionRepository> _regionRepo = new();
+    private readonly Mock<IUnitOfWork> _uow = new();
+    private readonly Mock<ICurrentUserService> _currentUser = new();
+    private readonly Mock<IScopeAccessService> _scopeAccess = new();
+    private readonly RouteService _sut;
+
+    private static readonly Guid RepUserId = Guid.NewGuid();
+
+    public RouteServiceTests()
+    {
+        _currentUser.Setup(u => u.RoleLevel).Returns(20);
+        _currentUser.Setup(u => u.UserId).Returns(RepUserId);
+        _sut = new RouteService(_repo.Object, _regionRepo.Object, _uow.Object, _currentUser.Object, _scopeAccess.Object);
+    }
+
+    private static Models.Route ActiveRoute(Guid? ownerId = null) =>
+        new() { Id = Guid.NewGuid(), RouteName = "R1", StartPoint = "A", EndPoint = "B", Length = 10, IsActive = true, FK_OwnerUserId = ownerId };
+
+    private static Models.Route InactiveRoute() =>
+        new() { Id = Guid.NewGuid(), RouteName = "Old", StartPoint = "A", EndPoint = "B", Length = 10, IsActive = false };
+
+    private static Store ActiveStore(Guid routeId, decimal lat = 10m, decimal lon = 20m) =>
+        new() { Id = Guid.NewGuid(), FK_RouteId = routeId, IsActive = true, Latitude = lat, Longitude = lon };
+
+    // AssignStoresToRouteAsync
+
+    [Fact]
+    public async Task AssignStoresToRouteAsync_ReturnsNull_WhenRouteNotFound()
+    {
+        _repo.Setup(r => r.GetByIdAsync(It.IsAny<Guid>())).ReturnsAsync((Models.Route?)null);
+
+        var result = await _sut.AssignStoresToRouteAsync(Guid.NewGuid(), new AssignStoresToRouteRequest([Guid.NewGuid()]));
+
+        Assert.Null(result);
+        _uow.Verify(u => u.BeginAsync(default), Times.Never);
+    }
+
+    [Fact]
+    public async Task AssignStoresToRouteAsync_ReturnsNull_WhenRouteInactive()
+    {
+        _repo.Setup(r => r.GetByIdAsync(It.IsAny<Guid>())).ReturnsAsync(InactiveRoute());
+
+        var result = await _sut.AssignStoresToRouteAsync(Guid.NewGuid(), new AssignStoresToRouteRequest([Guid.NewGuid()]));
+
+        Assert.Null(result);
+    }
+
+    [Fact]
+    public async Task AssignStoresToRouteAsync_ReturnsNull_WhenCallerLacksRouteScope()
+    {
+        var route = ActiveRoute();
+        _repo.Setup(r => r.GetByIdAsync(route.Id)).ReturnsAsync(route);
+        _scopeAccess.Setup(s => s.HasRouteScopeAsync(RepUserId, route.Id)).ReturnsAsync(false);
+
+        var result = await _sut.AssignStoresToRouteAsync(route.Id, new AssignStoresToRouteRequest([Guid.NewGuid()]));
+
+        Assert.Null(result);
+        _uow.Verify(u => u.BeginAsync(default), Times.Never);
+    }
+
+    [Fact]
+    public async Task AssignStoresToRouteAsync_ReturnsNull_WhenCallerBelowRoleFloor()
+    {
+        _currentUser.Setup(u => u.RoleLevel).Returns(10);
+        var route = ActiveRoute();
+        _repo.Setup(r => r.GetByIdAsync(route.Id)).ReturnsAsync(route);
+
+        var result = await _sut.AssignStoresToRouteAsync(route.Id, new AssignStoresToRouteRequest([Guid.NewGuid()]));
+
+        Assert.Null(result);
+    }
+
+    [Fact]
+    public async Task AssignStoresToRouteAsync_ReturnsNull_WhenAnyStoreIdMissing()
+    {
+        var route = ActiveRoute();
+        _repo.Setup(r => r.GetByIdAsync(route.Id)).ReturnsAsync(route);
+        _scopeAccess.Setup(s => s.HasRouteScopeAsync(RepUserId, route.Id)).ReturnsAsync(true);
+        var storeIds = new List<Guid> { Guid.NewGuid(), Guid.NewGuid() };
+        _repo.Setup(r => r.GetStoresByIdsAsync(storeIds)).ReturnsAsync([ActiveStore(route.Id)]); // only one of two found
+
+        var result = await _sut.AssignStoresToRouteAsync(route.Id, new AssignStoresToRouteRequest(storeIds));
+
+        Assert.Null(result);
+        _uow.Verify(u => u.BeginAsync(default), Times.Never);
+    }
+
+    [Fact]
+    public async Task AssignStoresToRouteAsync_UpdatesEachStore_AndCommits()
+    {
+        var route = ActiveRoute();
+        var otherRouteId = Guid.NewGuid();
+        var stores = new List<Store> { ActiveStore(otherRouteId), ActiveStore(otherRouteId) };
+        var storeIds = stores.Select(s => s.Id).ToList();
+        _repo.Setup(r => r.GetByIdAsync(route.Id)).ReturnsAsync(route);
+        _scopeAccess.Setup(s => s.HasRouteScopeAsync(RepUserId, route.Id)).ReturnsAsync(true);
+        _repo.Setup(r => r.GetStoresByIdsAsync(storeIds)).ReturnsAsync(stores);
+
+        var result = await _sut.AssignStoresToRouteAsync(route.Id, new AssignStoresToRouteRequest(storeIds));
+
+        Assert.NotNull(result);
+        Assert.All(stores, s => Assert.Equal(route.Id, s.FK_RouteId));
+        _repo.Verify(r => r.UpdateStore(It.IsAny<Store>()), Times.Exactly(2));
+        _uow.Verify(u => u.CommitAsync(default), Times.Once);
+    }
+
+    [Fact]
+    public async Task AssignStoresToRouteAsync_Rollbacks_WhenUpdateThrows()
+    {
+        var route = ActiveRoute();
+        var stores = new List<Store> { ActiveStore(route.Id) };
+        var storeIds = stores.Select(s => s.Id).ToList();
+        _repo.Setup(r => r.GetByIdAsync(route.Id)).ReturnsAsync(route);
+        _scopeAccess.Setup(s => s.HasRouteScopeAsync(RepUserId, route.Id)).ReturnsAsync(true);
+        _repo.Setup(r => r.GetStoresByIdsAsync(storeIds)).ReturnsAsync(stores);
+        _repo.Setup(r => r.UpdateStore(It.IsAny<Store>())).Throws(new Exception("db error"));
+
+        await Assert.ThrowsAsync<Exception>(() => _sut.AssignStoresToRouteAsync(route.Id, new AssignStoresToRouteRequest(storeIds)));
+
+        _uow.Verify(u => u.RollbackAsync(default), Times.Once);
+        _uow.Verify(u => u.CommitAsync(default), Times.Never);
+    }
+
+    // AssignOwnerAsync
+
+    [Fact]
+    public async Task AssignOwnerAsync_ReturnsNull_WhenRouteNotFound()
+    {
+        _repo.Setup(r => r.GetByIdAsync(It.IsAny<Guid>())).ReturnsAsync((Models.Route?)null);
+
+        var result = await _sut.AssignOwnerAsync(Guid.NewGuid(), new AssignRouteOwnerRequest(Guid.NewGuid()));
+
+        Assert.Null(result);
+    }
+
+    [Fact]
+    public async Task AssignOwnerAsync_ReturnsNull_WhenTargetUserNotActive()
+    {
+        var route = ActiveRoute();
+        _repo.Setup(r => r.GetByIdAsync(route.Id)).ReturnsAsync(route);
+        _scopeAccess.Setup(s => s.HasRouteScopeAsync(RepUserId, route.Id)).ReturnsAsync(true);
+        _repo.Setup(r => r.GetActiveUserAsync(It.IsAny<Guid>())).ReturnsAsync((User?)null);
+
+        var result = await _sut.AssignOwnerAsync(route.Id, new AssignRouteOwnerRequest(Guid.NewGuid()));
+
+        Assert.Null(result);
+        _uow.Verify(u => u.BeginAsync(default), Times.Never);
+    }
+
+    [Fact]
+    public async Task AssignOwnerAsync_SetsOwner_AndCommits()
+    {
+        var route = ActiveRoute();
+        var salesRep = new User { Id = Guid.NewGuid(), IsActive = true };
+        _repo.Setup(r => r.GetByIdAsync(route.Id)).ReturnsAsync(route);
+        _scopeAccess.Setup(s => s.HasRouteScopeAsync(RepUserId, route.Id)).ReturnsAsync(true);
+        _repo.Setup(r => r.GetActiveUserAsync(salesRep.Id)).ReturnsAsync(salesRep);
+
+        var result = await _sut.AssignOwnerAsync(route.Id, new AssignRouteOwnerRequest(salesRep.Id));
+
+        Assert.NotNull(result);
+        Assert.Equal(salesRep.Id, result.OwnerUserId);
+        Assert.Equal(salesRep.Id, route.FK_OwnerUserId);
+        _uow.Verify(u => u.CommitAsync(default), Times.Once);
+    }
+
+    [Fact]
+    public async Task AssignOwnerAsync_AllowsReassignment_ToDifferentSalesRep()
+    {
+        var firstOwner = Guid.NewGuid();
+        var route = ActiveRoute(firstOwner);
+        var newRep = new User { Id = Guid.NewGuid(), IsActive = true };
+        _repo.Setup(r => r.GetByIdAsync(route.Id)).ReturnsAsync(route);
+        _scopeAccess.Setup(s => s.HasRouteScopeAsync(RepUserId, route.Id)).ReturnsAsync(true);
+        _repo.Setup(r => r.GetActiveUserAsync(newRep.Id)).ReturnsAsync(newRep);
+
+        var result = await _sut.AssignOwnerAsync(route.Id, new AssignRouteOwnerRequest(newRep.Id));
+
+        Assert.NotNull(result);
+        Assert.Equal(newRep.Id, result.OwnerUserId);
+        Assert.NotEqual(firstOwner, result.OwnerUserId);
+    }
+
+    // RecordCheckInAsync
+
+    [Fact]
+    public async Task RecordCheckInAsync_ReturnsNull_WhenCallerNotAuthenticated()
+    {
+        _currentUser.Setup(u => u.UserId).Returns((Guid?)null);
+
+        var result = await _sut.RecordCheckInAsync(Guid.NewGuid(), new RecordCheckInRequest(Guid.NewGuid(), 1, 2, null));
+
+        Assert.Null(result);
+    }
+
+    [Fact]
+    public async Task RecordCheckInAsync_ReturnsNull_WhenRouteNotFoundOrInactive()
+    {
+        _repo.Setup(r => r.GetByIdAsync(It.IsAny<Guid>())).ReturnsAsync(InactiveRoute());
+
+        var result = await _sut.RecordCheckInAsync(Guid.NewGuid(), new RecordCheckInRequest(Guid.NewGuid(), 1, 2, null));
+
+        Assert.Null(result);
+    }
+
+    [Fact]
+    public async Task RecordCheckInAsync_ReturnsNull_WhenCallerLacksRouteScope()
+    {
+        var route = ActiveRoute();
+        _repo.Setup(r => r.GetByIdAsync(route.Id)).ReturnsAsync(route);
+        _scopeAccess.Setup(s => s.HasRouteScopeAsync(RepUserId, route.Id)).ReturnsAsync(false);
+
+        var result = await _sut.RecordCheckInAsync(route.Id, new RecordCheckInRequest(Guid.NewGuid(), 1, 2, null));
+
+        Assert.Null(result);
+    }
+
+    [Fact]
+    public async Task RecordCheckInAsync_ReturnsNull_WhenStoreNotOnRoute()
+    {
+        var route = ActiveRoute();
+        var store = ActiveStore(Guid.NewGuid()); // belongs to a different route
+        _repo.Setup(r => r.GetByIdAsync(route.Id)).ReturnsAsync(route);
+        _scopeAccess.Setup(s => s.HasRouteScopeAsync(RepUserId, route.Id)).ReturnsAsync(true);
+        _repo.Setup(r => r.GetStoreByIdAsync(store.Id)).ReturnsAsync(store);
+
+        var result = await _sut.RecordCheckInAsync(route.Id, new RecordCheckInRequest(store.Id, 1, 2, null));
+
+        Assert.Null(result);
+    }
+
+    [Fact]
+    public async Task RecordCheckInAsync_NotFlagged_WhenGpsMatchesStoreLocation()
+    {
+        var route = ActiveRoute();
+        var store = ActiveStore(route.Id, lat: 12.9716m, lon: 77.5946m);
+        _repo.Setup(r => r.GetByIdAsync(route.Id)).ReturnsAsync(route);
+        _scopeAccess.Setup(s => s.HasRouteScopeAsync(RepUserId, route.Id)).ReturnsAsync(true);
+        _repo.Setup(r => r.GetStoreByIdAsync(store.Id)).ReturnsAsync(store);
+
+        var result = await _sut.RecordCheckInAsync(route.Id, new RecordCheckInRequest(store.Id, 12.9716m, 77.5946m, null));
+
+        Assert.NotNull(result);
+        Assert.False(result.IsDeviationFlagged);
+        _repo.Verify(r => r.AddVisitLogAsync(It.IsAny<RouteVisitLog>()), Times.Once);
+        _uow.Verify(u => u.CommitAsync(default), Times.Once);
+    }
+
+    [Fact]
+    public async Task RecordCheckInAsync_Flagged_WhenGpsFarFromStoreLocation()
+    {
+        var route = ActiveRoute();
+        var store = ActiveStore(route.Id, lat: 12.9716m, lon: 77.5946m); // Bengaluru
+        _repo.Setup(r => r.GetByIdAsync(route.Id)).ReturnsAsync(route);
+        _scopeAccess.Setup(s => s.HasRouteScopeAsync(RepUserId, route.Id)).ReturnsAsync(true);
+        _repo.Setup(r => r.GetStoreByIdAsync(store.Id)).ReturnsAsync(store);
+
+        // Mumbai coordinates - hundreds of km away
+        var result = await _sut.RecordCheckInAsync(route.Id, new RecordCheckInRequest(store.Id, 19.0760m, 72.8777m, null));
+
+        Assert.NotNull(result);
+        Assert.True(result.IsDeviationFlagged);
+    }
+
+    [Fact]
+    public async Task RecordCheckInAsync_UsesCurrentUserId_AsVisitingRep()
+    {
+        var route = ActiveRoute();
+        var store = ActiveStore(route.Id);
+        _repo.Setup(r => r.GetByIdAsync(route.Id)).ReturnsAsync(route);
+        _scopeAccess.Setup(s => s.HasRouteScopeAsync(RepUserId, route.Id)).ReturnsAsync(true);
+        _repo.Setup(r => r.GetStoreByIdAsync(store.Id)).ReturnsAsync(store);
+
+        var result = await _sut.RecordCheckInAsync(route.Id, new RecordCheckInRequest(store.Id, store.Latitude, store.Longitude, null));
+
+        Assert.NotNull(result);
+        Assert.Equal(RepUserId, result.UserId);
+    }
+
+    // RecordCheckOutAsync
+
+    [Fact]
+    public async Task RecordCheckOutAsync_ReturnsNull_WhenNoOpenVisit()
+    {
+        var route = ActiveRoute();
+        _repo.Setup(r => r.GetByIdAsync(route.Id)).ReturnsAsync(route);
+        _scopeAccess.Setup(s => s.HasRouteScopeAsync(RepUserId, route.Id)).ReturnsAsync(true);
+        _repo.Setup(r => r.GetOpenVisitAsync(route.Id, It.IsAny<Guid>())).ReturnsAsync((RouteVisitLog?)null);
+
+        var result = await _sut.RecordCheckOutAsync(route.Id, new RecordCheckOutRequest(Guid.NewGuid(), null));
+
+        Assert.Null(result);
+        _uow.Verify(u => u.BeginAsync(default), Times.Never);
+    }
+
+    [Fact]
+    public async Task RecordCheckOutAsync_SetsCheckOutAt_AndCommits()
+    {
+        var route = ActiveRoute();
+        var storeId = Guid.NewGuid();
+        var log = new RouteVisitLog { Id = Guid.NewGuid(), FK_RouteId = route.Id, FK_StoreId = storeId, FK_UserId = RepUserId, CheckInAt = DateTime.Now.AddHours(-1) };
+        _repo.Setup(r => r.GetByIdAsync(route.Id)).ReturnsAsync(route);
+        _scopeAccess.Setup(s => s.HasRouteScopeAsync(RepUserId, route.Id)).ReturnsAsync(true);
+        _repo.Setup(r => r.GetOpenVisitAsync(route.Id, storeId)).ReturnsAsync(log);
+
+        var result = await _sut.RecordCheckOutAsync(route.Id, new RecordCheckOutRequest(storeId, null));
+
+        Assert.NotNull(result);
+        Assert.NotNull(result.CheckOutAt);
+        Assert.NotNull(log.CheckOutAt);
+        _repo.Verify(r => r.UpdateVisitLog(log), Times.Once);
+        _uow.Verify(u => u.CommitAsync(default), Times.Once);
+    }
+
+    [Fact]
+    public async Task RecordCheckOutAsync_Rollbacks_WhenUpdateThrows()
+    {
+        var route = ActiveRoute();
+        var storeId = Guid.NewGuid();
+        var log = new RouteVisitLog { Id = Guid.NewGuid(), FK_RouteId = route.Id, FK_StoreId = storeId, FK_UserId = RepUserId, CheckInAt = DateTime.Now };
+        _repo.Setup(r => r.GetByIdAsync(route.Id)).ReturnsAsync(route);
+        _scopeAccess.Setup(s => s.HasRouteScopeAsync(RepUserId, route.Id)).ReturnsAsync(true);
+        _repo.Setup(r => r.GetOpenVisitAsync(route.Id, storeId)).ReturnsAsync(log);
+        _repo.Setup(r => r.UpdateVisitLog(It.IsAny<RouteVisitLog>())).Throws(new Exception("db error"));
+
+        await Assert.ThrowsAsync<Exception>(() => _sut.RecordCheckOutAsync(route.Id, new RecordCheckOutRequest(storeId, null)));
+
+        _uow.Verify(u => u.RollbackAsync(default), Times.Once);
+    }
+}

Distribution.Tests/Services/ScopeAccessServiceTests.cs

@@ -0,0 +1,163 @@
+using Distribution.Infra.Authorization;
+using Moq;
+using Xunit;
+
+namespace Distribution.Tests.Services;
+
+public class ScopeAccessServiceTests
+{
+    private readonly Mock<IScopeRepository> _repo = new();
+    private readonly ScopeAccessService _sut;
+    private readonly Guid _userId = Guid.NewGuid();
+
+    public ScopeAccessServiceTests()
+    {
+        _sut = new ScopeAccessService(_repo.Object);
+    }
+
+    // Delegation tests
+
+    [Fact]
+    public async Task HasStoreScopeAsync_DelegatesToRepository()
+    {
+        var storeId = Guid.NewGuid();
+        _repo.Setup(r => r.HasStoreScopeAsync(_userId, storeId)).ReturnsAsync(true);
+
+        var result = await _sut.HasStoreScopeAsync(_userId, storeId);
+
+        Assert.True(result);
+        _repo.Verify(r => r.HasStoreScopeAsync(_userId, storeId), Times.Once);
+    }
+
+    [Fact]
+    public async Task HasRouteScopeAsync_DelegatesToRepository()
+    {
+        var routeId = Guid.NewGuid();
+        _repo.Setup(r => r.HasRouteScopeAsync(_userId, routeId)).ReturnsAsync(false);
+
+        var result = await _sut.HasRouteScopeAsync(_userId, routeId);
+
+        Assert.False(result);
+    }
+
+    [Fact]
+    public async Task HasRegionScopeAsync_DelegatesToRepository()
+    {
+        var regionId = Guid.NewGuid();
+        _repo.Setup(r => r.HasRegionScopeAsync(_userId, regionId)).ReturnsAsync(true);
+
+        var result = await _sut.HasRegionScopeAsync(_userId, regionId);
+
+        Assert.True(result);
+    }
+
+    // GetAccessibleStoreIdsAsync
+
+    [Fact]
+    public async Task GetAccessibleStoreIdsAsync_ReturnsEmpty_WhenNoAssignments()
+    {
+        _repo.Setup(r => r.GetDirectStoreIdsAsync(_userId)).ReturnsAsync([]);
+        _repo.Setup(r => r.GetRouteIdsAsync(_userId)).ReturnsAsync([]);
+        _repo.Setup(r => r.GetRegionIdsAsync(_userId)).ReturnsAsync([]);
+        _repo.Setup(r => r.GetStoreIdsByRouteIdsAsync(It.IsAny<List<Guid>>())).ReturnsAsync([]);
+        _repo.Setup(r => r.GetRouteIdsByRegionIdsAsync(It.IsAny<List<Guid>>())).ReturnsAsync([]);
+
+        var result = await _sut.GetAccessibleStoreIdsAsync(_userId);
+
+        Assert.Empty(result);
+    }
+
+    [Fact]
+    public async Task GetAccessibleStoreIdsAsync_ReturnsDirectStores()
+    {
+        var storeId = Guid.NewGuid();
+        _repo.Setup(r => r.GetDirectStoreIdsAsync(_userId)).ReturnsAsync([storeId]);
+        _repo.Setup(r => r.GetRouteIdsAsync(_userId)).ReturnsAsync([]);
+        _repo.Setup(r => r.GetRegionIdsAsync(_userId)).ReturnsAsync([]);
+        _repo.Setup(r => r.GetStoreIdsByRouteIdsAsync(It.IsAny<List<Guid>>())).ReturnsAsync([]);
+        _repo.Setup(r => r.GetRouteIdsByRegionIdsAsync(It.IsAny<List<Guid>>())).ReturnsAsync([]);
+
+        var result = await _sut.GetAccessibleStoreIdsAsync(_userId);
+
+        Assert.Single(result);
+        Assert.Contains(storeId, result);
+    }
+
+    [Fact]
+    public async Task GetAccessibleStoreIdsAsync_IncludesStoresViaRoute()
+    {
+        var routeId = Guid.NewGuid();
+        var storeViaRoute = Guid.NewGuid();
+        _repo.Setup(r => r.GetDirectStoreIdsAsync(_userId)).ReturnsAsync([]);
+        _repo.Setup(r => r.GetRouteIdsAsync(_userId)).ReturnsAsync([routeId]);
+        _repo.Setup(r => r.GetRegionIdsAsync(_userId)).ReturnsAsync([]);
+        _repo.Setup(r => r.GetStoreIdsByRouteIdsAsync(new List<Guid> { routeId })).ReturnsAsync([storeViaRoute]);
+        _repo.Setup(r => r.GetRouteIdsByRegionIdsAsync(It.IsAny<List<Guid>>())).ReturnsAsync([]);
+        _repo.Setup(r => r.GetStoreIdsByRouteIdsAsync(new List<Guid>())).ReturnsAsync([]);
+
+        var result = await _sut.GetAccessibleStoreIdsAsync(_userId);
+
+        Assert.Contains(storeViaRoute, result);
+    }
+
+    [Fact]
+    public async Task GetAccessibleStoreIdsAsync_IncludesStoresViaRegion()
+    {
+        var regionId = Guid.NewGuid();
+        var routeViaRegion = Guid.NewGuid();
+        var storeViaRegion = Guid.NewGuid();
+        _repo.Setup(r => r.GetDirectStoreIdsAsync(_userId)).ReturnsAsync([]);
+        _repo.Setup(r => r.GetRouteIdsAsync(_userId)).ReturnsAsync([]);
+        _repo.Setup(r => r.GetRegionIdsAsync(_userId)).ReturnsAsync([regionId]);
+        _repo.Setup(r => r.GetStoreIdsByRouteIdsAsync(new List<Guid>())).ReturnsAsync([]);
+        _repo.Setup(r => r.GetRouteIdsByRegionIdsAsync(new List<Guid> { regionId })).ReturnsAsync([routeViaRegion]);
+        _repo.Setup(r => r.GetStoreIdsByRouteIdsAsync(new List<Guid> { routeViaRegion })).ReturnsAsync([storeViaRegion]);
+
+        var result = await _sut.GetAccessibleStoreIdsAsync(_userId);
+
+        Assert.Contains(storeViaRegion, result);
+    }
+
+    [Fact]
+    public async Task GetAccessibleStoreIdsAsync_DeduplicatesStores()
+    {
+        var sharedStoreId = Guid.NewGuid();
+        var routeId = Guid.NewGuid();
+        _repo.Setup(r => r.GetDirectStoreIdsAsync(_userId)).ReturnsAsync([sharedStoreId]);
+        _repo.Setup(r => r.GetRouteIdsAsync(_userId)).ReturnsAsync([routeId]);
+        _repo.Setup(r => r.GetRegionIdsAsync(_userId)).ReturnsAsync([]);
+        _repo.Setup(r => r.GetStoreIdsByRouteIdsAsync(new List<Guid> { routeId })).ReturnsAsync([sharedStoreId]);
+        _repo.Setup(r => r.GetRouteIdsByRegionIdsAsync(It.IsAny<List<Guid>>())).ReturnsAsync([]);
+        _repo.Setup(r => r.GetStoreIdsByRouteIdsAsync(new List<Guid>())).ReturnsAsync([]);
+
+        var result = await _sut.GetAccessibleStoreIdsAsync(_userId);
+
+        Assert.Single(result);
+        Assert.Equal(sharedStoreId, result[0]);
+    }
+
+    [Fact]
+    public async Task GetAccessibleStoreIdsAsync_CombinesAllSources()
+    {
+        var directStore = Guid.NewGuid();
+        var routeStore = Guid.NewGuid();
+        var regionStore = Guid.NewGuid();
+        var routeId = Guid.NewGuid();
+        var regionId = Guid.NewGuid();
+        var routeViaRegion = Guid.NewGuid();
+
+        _repo.Setup(r => r.GetDirectStoreIdsAsync(_userId)).ReturnsAsync([directStore]);
+        _repo.Setup(r => r.GetRouteIdsAsync(_userId)).ReturnsAsync([routeId]);
+        _repo.Setup(r => r.GetRegionIdsAsync(_userId)).ReturnsAsync([regionId]);
+        _repo.Setup(r => r.GetStoreIdsByRouteIdsAsync(new List<Guid> { routeId })).ReturnsAsync([routeStore]);
+        _repo.Setup(r => r.GetRouteIdsByRegionIdsAsync(new List<Guid> { regionId })).ReturnsAsync([routeViaRegion]);
+        _repo.Setup(r => r.GetStoreIdsByRouteIdsAsync(new List<Guid> { routeViaRegion })).ReturnsAsync([regionStore]);
+
+        var result = await _sut.GetAccessibleStoreIdsAsync(_userId);
+
+        Assert.Equal(3, result.Count);
+        Assert.Contains(directStore, result);
+        Assert.Contains(routeStore, result);
+        Assert.Contains(regionStore, result);
+    }
+}

Distribution.Tests/Services/StoreServiceTests.cs

@@ -0,0 +1,85 @@
+using Distribution.Features.Item;
+using Distribution.Features.Order;
+using Distribution.Features.Route;
+using Distribution.Features.Scheme;
+using Distribution.Features.Stock;
+using Distribution.Features.Store;
+using Distribution.Infra.Authorization;
+using Distribution.Infra.UoW;
+using Distribution.Models;
+using Moq;
+using Xunit;
+
+namespace Distribution.Tests.Services;
+
+public class StoreServiceTests
+{
+    private readonly Mock<IStoreRepository> _repo = new();
+    private readonly Mock<IUnitOfWork> _uow = new();
+    private readonly Mock<ICurrentUserService> _currentUser = new();
+    private readonly Mock<IScopeAccessService> _scopeAccess = new();
+    private readonly Mock<IRouteRepository> _routeRepo = new();
+    private readonly StoreService _sut;
+
+    public StoreServiceTests()
+    {
+        _currentUser.Setup(u => u.RoleLevel).Returns(50); // global scope, skips per-store scope lookups
+        var schemeService = new SchemeService(
+            Mock.Of<ISchemeRepository>(),
+            Mock.Of<IOrderRepository>(),
+            Mock.Of<IItemRepository>(),
+            _repo.Object,
+            Mock.Of<IStockRepository>(),
+            _uow.Object);
+        _sut = new StoreService(_repo.Object, _uow.Object, _currentUser.Object, _scopeAccess.Object, schemeService, _routeRepo.Object);
+    }
+
+    private static Store ActiveStore() =>
+        new() { Id = Guid.NewGuid(), IsActive = true };
+
+    // GetVisitHistoryAsync
+
+    [Fact]
+    public async Task GetVisitHistoryAsync_ReturnsNull_WhenStoreNotFound()
+    {
+        _repo.Setup(r => r.GetByIdAsync(It.IsAny<Guid>())).ReturnsAsync((Store?)null);
+
+        var result = await _sut.GetVisitHistoryAsync(Guid.NewGuid());
+
+        Assert.Null(result);
+    }
+
+    [Fact]
+    public async Task GetVisitHistoryAsync_ReturnsEmpty_WhenNoVisitsLogged()
+    {
+        var store = ActiveStore();
+        _repo.Setup(r => r.GetByIdAsync(store.Id)).ReturnsAsync(store);
+        _routeRepo.Setup(r => r.GetVisitsByStoreIdAsync(store.Id)).ReturnsAsync([]);
+
+        var result = await _sut.GetVisitHistoryAsync(store.Id);
+
+        Assert.NotNull(result);
+        Assert.Empty(result);
+    }
+
+    [Fact]
+    public async Task GetVisitHistoryAsync_MapsVisits_MostRecentFirst()
+    {
+        var store = ActiveStore();
+        var repId = Guid.NewGuid();
+        var older = new RouteVisitLog { Id = Guid.NewGuid(), FK_StoreId = store.Id, FK_UserId = repId, CheckInAt = DateTime.Now.AddDays(-2), CheckOutAt = DateTime.Now.AddDays(-2).AddHours(1) };
+        var newer = new RouteVisitLog { Id = Guid.NewGuid(), FK_StoreId = store.Id, FK_UserId = repId, CheckInAt = DateTime.Now.AddDays(-1), CheckOutAt = null };
+        _repo.Setup(r => r.GetByIdAsync(store.Id)).ReturnsAsync(store);
+        _routeRepo.Setup(r => r.GetVisitsByStoreIdAsync(store.Id)).ReturnsAsync([older, newer]);
+
+        var result = await _sut.GetVisitHistoryAsync(store.Id);
+
+        Assert.NotNull(result);
+        Assert.Equal(2, result.Count);
+        Assert.Equal(newer.Id, result[0].VisitId);
+        Assert.Equal("In Progress", result[0].Outcome);
+        Assert.Equal(older.Id, result[1].VisitId);
+        Assert.Equal("Completed", result[1].Outcome);
+        Assert.Equal(repId, result[0].RepUserId);
+    }
+}

Distribution.Tests/bin/Debug/net9.0/Distribution.Tests.deps.json

@@ -0,0 +1,799 @@
+{
+  "runtimeTarget": {
+    "name": ".NETCoreApp,Version=v9.0",
+    "signature": ""
+  },
+  "compilationOptions": {},
+  "targets": {
+    ".NETCoreApp,Version=v9.0": {
+      "Distribution.Tests/1.0.0": {
+        "dependencies": {
+          "Distribution": "1.0.0",
+          "Microsoft.NET.Test.Sdk": "17.12.0",
+          "Moq": "4.20.72",
+          "xunit": "2.9.3"
+        },
+        "runtime": {
+          "Distribution.Tests.dll": {}
+        }
+      },
+      "Castle.Core/5.1.1": {
+        "runtime": {
+          "lib/net6.0/Castle.Core.dll": {
+            "assemblyVersion": "5.0.0.0",
+            "fileVersion": "5.1.1.0"
+          }
+        }
+      },
+      "Microsoft.AspNetCore.Authentication.JwtBearer/9.0.0": {
+        "dependencies": {
+          "Microsoft.IdentityModel.Protocols.OpenIdConnect": "8.0.1"
+        },
+        "runtime": {
+          "lib/net9.0/Microsoft.AspNetCore.Authentication.JwtBearer.dll": {
+            "assemblyVersion": "9.0.0.0",
+            "fileVersion": "9.0.24.52903"
+          }
+        }
+      },
+      "Microsoft.AspNetCore.OpenApi/9.0.0": {
+        "dependencies": {
+          "Microsoft.OpenApi": "1.6.22"
+        },
+        "runtime": {
+          "lib/net9.0/Microsoft.AspNetCore.OpenApi.dll": {
+            "assemblyVersion": "9.0.0.0",
+            "fileVersion": "9.0.24.52903"
+          }
+        }
+      },
+      "Microsoft.CodeCoverage/17.12.0": {
+        "runtime": {
+          "lib/netcoreapp3.1/Microsoft.VisualStudio.CodeCoverage.Shim.dll": {
+            "assemblyVersion": "15.0.0.0",
+            "fileVersion": "17.1200.524.48002"
+          }
+        }
+      },
+      "Microsoft.EntityFrameworkCore/9.0.0": {
+        "dependencies": {
+          "Microsoft.EntityFrameworkCore.Abstractions": "9.0.0"
+        },
+        "runtime": {
+          "lib/net8.0/Microsoft.EntityFrameworkCore.dll": {
+            "assemblyVersion": "9.0.0.0",
+            "fileVersion": "9.0.24.52902"
+          }
+        }
+      },
+      "Microsoft.EntityFrameworkCore.Abstractions/9.0.0": {
+        "runtime": {
+          "lib/net8.0/Microsoft.EntityFrameworkCore.Abstractions.dll": {
+            "assemblyVersion": "9.0.0.0",
+            "fileVersion": "9.0.24.52902"
+          }
+        }
+      },
+      "Microsoft.EntityFrameworkCore.Relational/9.0.0": {
+        "dependencies": {
+          "Microsoft.EntityFrameworkCore": "9.0.0"
+        },
+        "runtime": {
+          "lib/net8.0/Microsoft.EntityFrameworkCore.Relational.dll": {
+            "assemblyVersion": "9.0.0.0",
+            "fileVersion": "9.0.24.52902"
+          }
+        }
+      },
+      "Microsoft.IdentityModel.Abstractions/8.0.1": {
+        "runtime": {
+          "lib/net9.0/Microsoft.IdentityModel.Abstractions.dll": {
+            "assemblyVersion": "8.0.1.0",
+            "fileVersion": "8.0.1.50722"
+          }
+        }
+      },
+      "Microsoft.IdentityModel.JsonWebTokens/8.0.1": {
+        "dependencies": {
+          "Microsoft.IdentityModel.Tokens": "8.0.1"
+        },
+        "runtime": {
+          "lib/net9.0/Microsoft.IdentityModel.JsonWebTokens.dll": {
+            "assemblyVersion": "8.0.1.0",
+            "fileVersion": "8.0.1.50722"
+          }
+        }
+      },
+      "Microsoft.IdentityModel.Logging/8.0.1": {
+        "dependencies": {
+          "Microsoft.IdentityModel.Abstractions": "8.0.1"
+        },
+        "runtime": {
+          "lib/net9.0/Microsoft.IdentityModel.Logging.dll": {
+            "assemblyVersion": "8.0.1.0",
+            "fileVersion": "8.0.1.50722"
+          }
+        }
+      },
+      "Microsoft.IdentityModel.Protocols/8.0.1": {
+        "dependencies": {
+          "Microsoft.IdentityModel.Tokens": "8.0.1"
+        },
+        "runtime": {
+          "lib/net9.0/Microsoft.IdentityModel.Protocols.dll": {
+            "assemblyVersion": "8.0.1.0",
+            "fileVersion": "8.0.1.50722"
+          }
+        }
+      },
+      "Microsoft.IdentityModel.Protocols.OpenIdConnect/8.0.1": {
+        "dependencies": {
+          "Microsoft.IdentityModel.Protocols": "8.0.1",
+          "System.IdentityModel.Tokens.Jwt": "8.0.1"
+        },
+        "runtime": {
+          "lib/net9.0/Microsoft.IdentityModel.Protocols.OpenIdConnect.dll": {
+            "assemblyVersion": "8.0.1.0",
+            "fileVersion": "8.0.1.50722"
+          }
+        }
+      },
+      "Microsoft.IdentityModel.Tokens/8.0.1": {
+        "dependencies": {
+          "Microsoft.IdentityModel.Logging": "8.0.1"
+        },
+        "runtime": {
+          "lib/net9.0/Microsoft.IdentityModel.Tokens.dll": {
+            "assemblyVersion": "8.0.1.0",
+            "fileVersion": "8.0.1.50722"
+          }
+        }
+      },
+      "Microsoft.NET.Test.Sdk/17.12.0": {
+        "dependencies": {
+          "Microsoft.CodeCoverage": "17.12.0",
+          "Microsoft.TestPlatform.TestHost": "17.12.0"
+        }
+      },
+      "Microsoft.OpenApi/1.6.22": {
+        "runtime": {
+          "lib/netstandard2.0/Microsoft.OpenApi.dll": {
+            "assemblyVersion": "1.6.22.0",
+            "fileVersion": "1.6.22.0"
+          }
+        }
+      },
+      "Microsoft.TestPlatform.ObjectModel/17.12.0": {
+        "runtime": {
+          "lib/netcoreapp3.1/Microsoft.TestPlatform.CoreUtilities.dll": {
+            "assemblyVersion": "15.0.0.0",
+            "fileVersion": "17.1200.24.56501"
+          },
+          "lib/netcoreapp3.1/Microsoft.TestPlatform.PlatformAbstractions.dll": {
+            "assemblyVersion": "15.0.0.0",
+            "fileVersion": "17.1200.24.56501"
+          },
+          "lib/netcoreapp3.1/Microsoft.VisualStudio.TestPlatform.ObjectModel.dll": {
+            "assemblyVersion": "15.0.0.0",
+            "fileVersion": "17.1200.24.56501"
+          }
+        },
+        "resources": {
+          "lib/netcoreapp3.1/cs/Microsoft.TestPlatform.CoreUtilities.resources.dll": {
+            "locale": "cs"
+          },
+          "lib/netcoreapp3.1/cs/Microsoft.VisualStudio.TestPlatform.ObjectModel.resources.dll": {
+            "locale": "cs"
+          },
+          "lib/netcoreapp3.1/de/Microsoft.TestPlatform.CoreUtilities.resources.dll": {
+            "locale": "de"
+          },
+          "lib/netcoreapp3.1/de/Microsoft.VisualStudio.TestPlatform.ObjectModel.resources.dll": {
+            "locale": "de"
+          },
+          "lib/netcoreapp3.1/es/Microsoft.TestPlatform.CoreUtilities.resources.dll": {
+            "locale": "es"
+          },
+          "lib/netcoreapp3.1/es/Microsoft.VisualStudio.TestPlatform.ObjectModel.resources.dll": {
+            "locale": "es"
+          },
+          "lib/netcoreapp3.1/fr/Microsoft.TestPlatform.CoreUtilities.resources.dll": {
+            "locale": "fr"
+          },
+          "lib/netcoreapp3.1/fr/Microsoft.VisualStudio.TestPlatform.ObjectModel.resources.dll": {
+            "locale": "fr"
+          },
+          "lib/netcoreapp3.1/it/Microsoft.TestPlatform.CoreUtilities.resources.dll": {
+            "locale": "it"
+          },
+          "lib/netcoreapp3.1/it/Microsoft.VisualStudio.TestPlatform.ObjectModel.resources.dll": {
+            "locale": "it"
+          },
+          "lib/netcoreapp3.1/ja/Microsoft.TestPlatform.CoreUtilities.resources.dll": {
+            "locale": "ja"
+          },
+          "lib/netcoreapp3.1/ja/Microsoft.VisualStudio.TestPlatform.ObjectModel.resources.dll": {
+            "locale": "ja"
+          },
+          "lib/netcoreapp3.1/ko/Microsoft.TestPlatform.CoreUtilities.resources.dll": {
+            "locale": "ko"
+          },
+          "lib/netcoreapp3.1/ko/Microsoft.VisualStudio.TestPlatform.ObjectModel.resources.dll": {
+            "locale": "ko"
+          },
+          "lib/netcoreapp3.1/pl/Microsoft.TestPlatform.CoreUtilities.resources.dll": {
+            "locale": "pl"
+          },
+          "lib/netcoreapp3.1/pl/Microsoft.VisualStudio.TestPlatform.ObjectModel.resources.dll": {
+            "locale": "pl"
+          },
+          "lib/netcoreapp3.1/pt-BR/Microsoft.TestPlatform.CoreUtilities.resources.dll": {
+            "locale": "pt-BR"
+          },
+          "lib/netcoreapp3.1/pt-BR/Microsoft.VisualStudio.TestPlatform.ObjectModel.resources.dll": {
+            "locale": "pt-BR"
+          },
+          "lib/netcoreapp3.1/ru/Microsoft.TestPlatform.CoreUtilities.resources.dll": {
+            "locale": "ru"
+          },
+          "lib/netcoreapp3.1/ru/Microsoft.VisualStudio.TestPlatform.ObjectModel.resources.dll": {
+            "locale": "ru"
+          },
+          "lib/netcoreapp3.1/tr/Microsoft.TestPlatform.CoreUtilities.resources.dll": {
+            "locale": "tr"
+          },
+          "lib/netcoreapp3.1/tr/Microsoft.VisualStudio.TestPlatform.ObjectModel.resources.dll": {
+            "locale": "tr"
+          },
+          "lib/netcoreapp3.1/zh-Hans/Microsoft.TestPlatform.CoreUtilities.resources.dll": {
+            "locale": "zh-Hans"
+          },
+          "lib/netcoreapp3.1/zh-Hans/Microsoft.VisualStudio.TestPlatform.ObjectModel.resources.dll": {
+            "locale": "zh-Hans"
+          },
+          "lib/netcoreapp3.1/zh-Hant/Microsoft.TestPlatform.CoreUtilities.resources.dll": {
+            "locale": "zh-Hant"
+          },
+          "lib/netcoreapp3.1/zh-Hant/Microsoft.VisualStudio.TestPlatform.ObjectModel.resources.dll": {
+            "locale": "zh-Hant"
+          }
+        }
+      },
+      "Microsoft.TestPlatform.TestHost/17.12.0": {
+        "dependencies": {
+          "Microsoft.TestPlatform.ObjectModel": "17.12.0",
+          "Newtonsoft.Json": "13.0.1"
+        },
+        "runtime": {
+          "lib/netcoreapp3.1/Microsoft.TestPlatform.CommunicationUtilities.dll": {
+            "assemblyVersion": "15.0.0.0",
+            "fileVersion": "17.1200.24.56501"
+          },
+          "lib/netcoreapp3.1/Microsoft.TestPlatform.CrossPlatEngine.dll": {
+            "assemblyVersion": "15.0.0.0",
+            "fileVersion": "17.1200.24.56501"
+          },
+          "lib/netcoreapp3.1/Microsoft.TestPlatform.Utilities.dll": {
+            "assemblyVersion": "15.0.0.0",
+            "fileVersion": "17.1200.24.56501"
+          },
+          "lib/netcoreapp3.1/Microsoft.VisualStudio.TestPlatform.Common.dll": {
+            "assemblyVersion": "15.0.0.0",
+            "fileVersion": "17.1200.24.56501"
+          },
+          "lib/netcoreapp3.1/testhost.dll": {
+            "assemblyVersion": "15.0.0.0",
+            "fileVersion": "17.1200.24.56501"
+          }
+        },
+        "resources": {
+          "lib/netcoreapp3.1/cs/Microsoft.TestPlatform.CommunicationUtilities.resources.dll": {
+            "locale": "cs"
+          },
+          "lib/netcoreapp3.1/cs/Microsoft.TestPlatform.CrossPlatEngine.resources.dll": {
+            "locale": "cs"
+          },
+          "lib/netcoreapp3.1/cs/Microsoft.VisualStudio.TestPlatform.Common.resources.dll": {
+            "locale": "cs"
+          },
+          "lib/netcoreapp3.1/de/Microsoft.TestPlatform.CommunicationUtilities.resources.dll": {
+            "locale": "de"
+          },
+          "lib/netcoreapp3.1/de/Microsoft.TestPlatform.CrossPlatEngine.resources.dll": {
+            "locale": "de"
+          },
+          "lib/netcoreapp3.1/de/Microsoft.VisualStudio.TestPlatform.Common.resources.dll": {
+            "locale": "de"
+          },
+          "lib/netcoreapp3.1/es/Microsoft.TestPlatform.CommunicationUtilities.resources.dll": {
+            "locale": "es"
+          },
+          "lib/netcoreapp3.1/es/Microsoft.TestPlatform.CrossPlatEngine.resources.dll": {
+            "locale": "es"
+          },
+          "lib/netcoreapp3.1/es/Microsoft.VisualStudio.TestPlatform.Common.resources.dll": {
+            "locale": "es"
+          },
+          "lib/netcoreapp3.1/fr/Microsoft.TestPlatform.CommunicationUtilities.resources.dll": {
+            "locale": "fr"
+          },
+          "lib/netcoreapp3.1/fr/Microsoft.TestPlatform.CrossPlatEngine.resources.dll": {
+            "locale": "fr"
+          },
+          "lib/netcoreapp3.1/fr/Microsoft.VisualStudio.TestPlatform.Common.resources.dll": {
+            "locale": "fr"
+          },
+          "lib/netcoreapp3.1/it/Microsoft.TestPlatform.CommunicationUtilities.resources.dll": {
+            "locale": "it"
+          },
+          "lib/netcoreapp3.1/it/Microsoft.TestPlatform.CrossPlatEngine.resources.dll": {
+            "locale": "it"
+          },
+          "lib/netcoreapp3.1/it/Microsoft.VisualStudio.TestPlatform.Common.resources.dll": {
+            "locale": "it"
+          },
+          "lib/netcoreapp3.1/ja/Microsoft.TestPlatform.CommunicationUtilities.resources.dll": {
+            "locale": "ja"
+          },
+          "lib/netcoreapp3.1/ja/Microsoft.TestPlatform.CrossPlatEngine.resources.dll": {
+            "locale": "ja"
+          },
+          "lib/netcoreapp3.1/ja/Microsoft.VisualStudio.TestPlatform.Common.resources.dll": {
+            "locale": "ja"
+          },
+          "lib/netcoreapp3.1/ko/Microsoft.TestPlatform.CommunicationUtilities.resources.dll": {
+            "locale": "ko"
+          },
+          "lib/netcoreapp3.1/ko/Microsoft.TestPlatform.CrossPlatEngine.resources.dll": {
+            "locale": "ko"
+          },
+          "lib/netcoreapp3.1/ko/Microsoft.VisualStudio.TestPlatform.Common.resources.dll": {
+            "locale": "ko"
+          },
+          "lib/netcoreapp3.1/pl/Microsoft.TestPlatform.CommunicationUtilities.resources.dll": {
+            "locale": "pl"
+          },
+          "lib/netcoreapp3.1/pl/Microsoft.TestPlatform.CrossPlatEngine.resources.dll": {
+            "locale": "pl"
+          },
+          "lib/netcoreapp3.1/pl/Microsoft.VisualStudio.TestPlatform.Common.resources.dll": {
+            "locale": "pl"
+          },
+          "lib/netcoreapp3.1/pt-BR/Microsoft.TestPlatform.CommunicationUtilities.resources.dll": {
+            "locale": "pt-BR"
+          },
+          "lib/netcoreapp3.1/pt-BR/Microsoft.TestPlatform.CrossPlatEngine.resources.dll": {
+            "locale": "pt-BR"
+          },
+          "lib/netcoreapp3.1/pt-BR/Microsoft.VisualStudio.TestPlatform.Common.resources.dll": {
+            "locale": "pt-BR"
+          },
+          "lib/netcoreapp3.1/ru/Microsoft.TestPlatform.CommunicationUtilities.resources.dll": {
+            "locale": "ru"
+          },
+          "lib/netcoreapp3.1/ru/Microsoft.TestPlatform.CrossPlatEngine.resources.dll": {
+            "locale": "ru"
+          },
+          "lib/netcoreapp3.1/ru/Microsoft.VisualStudio.TestPlatform.Common.resources.dll": {
+            "locale": "ru"
+          },
+          "lib/netcoreapp3.1/tr/Microsoft.TestPlatform.CommunicationUtilities.resources.dll": {
+            "locale": "tr"
+          },
+          "lib/netcoreapp3.1/tr/Microsoft.TestPlatform.CrossPlatEngine.resources.dll": {
+            "locale": "tr"
+          },
+          "lib/netcoreapp3.1/tr/Microsoft.VisualStudio.TestPlatform.Common.resources.dll": {
+            "locale": "tr"
+          },
+          "lib/netcoreapp3.1/zh-Hans/Microsoft.TestPlatform.CommunicationUtilities.resources.dll": {
+            "locale": "zh-Hans"
+          },
+          "lib/netcoreapp3.1/zh-Hans/Microsoft.TestPlatform.CrossPlatEngine.resources.dll": {
+            "locale": "zh-Hans"
+          },
+          "lib/netcoreapp3.1/zh-Hans/Microsoft.VisualStudio.TestPlatform.Common.resources.dll": {
+            "locale": "zh-Hans"
+          },
+          "lib/netcoreapp3.1/zh-Hant/Microsoft.TestPlatform.CommunicationUtilities.resources.dll": {
+            "locale": "zh-Hant"
+          },
+          "lib/netcoreapp3.1/zh-Hant/Microsoft.TestPlatform.CrossPlatEngine.resources.dll": {
+            "locale": "zh-Hant"
+          },
+          "lib/netcoreapp3.1/zh-Hant/Microsoft.VisualStudio.TestPlatform.Common.resources.dll": {
+            "locale": "zh-Hant"
+          }
+        }
+      },
+      "Moq/4.20.72": {
+        "dependencies": {
+          "Castle.Core": "5.1.1"
+        },
+        "runtime": {
+          "lib/net6.0/Moq.dll": {
+            "assemblyVersion": "4.20.72.0",
+            "fileVersion": "4.20.72.0"
+          }
+        }
+      },
+      "MySqlConnector/2.4.0": {
+        "runtime": {
+          "lib/net9.0/MySqlConnector.dll": {
+            "assemblyVersion": "2.0.0.0",
+            "fileVersion": "2.4.0.0"
+          }
+        }
+      },
+      "Newtonsoft.Json/13.0.1": {
+        "runtime": {
+          "lib/netstandard2.0/Newtonsoft.Json.dll": {
+            "assemblyVersion": "13.0.0.0",
+            "fileVersion": "13.0.1.25517"
+          }
+        }
+      },
+      "Pomelo.EntityFrameworkCore.MySql/9.0.0": {
+        "dependencies": {
+          "Microsoft.EntityFrameworkCore.Relational": "9.0.0",
+          "MySqlConnector": "2.4.0"
+        },
+        "runtime": {
+          "lib/net8.0/Pomelo.EntityFrameworkCore.MySql.dll": {
+            "assemblyVersion": "9.0.0.0",
+            "fileVersion": "9.0.0.0"
+          }
+        }
+      },
+      "Swashbuckle.AspNetCore/7.3.1": {
+        "dependencies": {
+          "Swashbuckle.AspNetCore.Swagger": "7.3.1",
+          "Swashbuckle.AspNetCore.SwaggerGen": "7.3.1",
+          "Swashbuckle.AspNetCore.SwaggerUI": "7.3.1"
+        }
+      },
+      "Swashbuckle.AspNetCore.Swagger/7.3.1": {
+        "dependencies": {
+          "Microsoft.OpenApi": "1.6.22"
+        },
+        "runtime": {
+          "lib/net9.0/Swashbuckle.AspNetCore.Swagger.dll": {
+            "assemblyVersion": "7.3.1.0",
+            "fileVersion": "7.3.1.1111"
+          }
+        }
+      },
+      "Swashbuckle.AspNetCore.SwaggerGen/7.3.1": {
+        "dependencies": {
+          "Swashbuckle.AspNetCore.Swagger": "7.3.1"
+        },
+        "runtime": {
+          "lib/net9.0/Swashbuckle.AspNetCore.SwaggerGen.dll": {
+            "assemblyVersion": "7.3.1.0",
+            "fileVersion": "7.3.1.1111"
+          }
+        }
+      },
+      "Swashbuckle.AspNetCore.SwaggerUI/7.3.1": {
+        "runtime": {
+          "lib/net9.0/Swashbuckle.AspNetCore.SwaggerUI.dll": {
+            "assemblyVersion": "7.3.1.0",
+            "fileVersion": "7.3.1.1111"
+          }
+        }
+      },
+      "System.IdentityModel.Tokens.Jwt/8.0.1": {
+        "dependencies": {
+          "Microsoft.IdentityModel.JsonWebTokens": "8.0.1",
+          "Microsoft.IdentityModel.Tokens": "8.0.1"
+        },
+        "runtime": {
+          "lib/net9.0/System.IdentityModel.Tokens.Jwt.dll": {
+            "assemblyVersion": "8.0.1.0",
+            "fileVersion": "8.0.1.50722"
+          }
+        }
+      },
+      "xunit/2.9.3": {
+        "dependencies": {
+          "xunit.assert": "2.9.3",
+          "xunit.core": "2.9.3"
+        }
+      },
+      "xunit.abstractions/2.0.3": {
+        "runtime": {
+          "lib/netstandard2.0/xunit.abstractions.dll": {
+            "assemblyVersion": "2.0.0.0",
+            "fileVersion": "2.0.0.0"
+          }
+        }
+      },
+      "xunit.assert/2.9.3": {
+        "runtime": {
+          "lib/net6.0/xunit.assert.dll": {
+            "assemblyVersion": "2.9.3.0",
+            "fileVersion": "2.9.3.0"
+          }
+        }
+      },
+      "xunit.core/2.9.3": {
+        "dependencies": {
+          "xunit.extensibility.core": "2.9.3",
+          "xunit.extensibility.execution": "2.9.3"
+        }
+      },
+      "xunit.extensibility.core/2.9.3": {
+        "dependencies": {
+          "xunit.abstractions": "2.0.3"
+        },
+        "runtime": {
+          "lib/netstandard1.1/xunit.core.dll": {
+            "assemblyVersion": "2.9.3.0",
+            "fileVersion": "2.9.3.0"
+          }
+        }
+      },
+      "xunit.extensibility.execution/2.9.3": {
+        "dependencies": {
+          "xunit.extensibility.core": "2.9.3"
+        },
+        "runtime": {
+          "lib/netstandard1.1/xunit.execution.dotnet.dll": {
+            "assemblyVersion": "2.9.3.0",
+            "fileVersion": "2.9.3.0"
+          }
+        }
+      },
+      "Distribution/1.0.0": {
+        "dependencies": {
+          "Microsoft.AspNetCore.Authentication.JwtBearer": "9.0.0",
+          "Microsoft.AspNetCore.OpenApi": "9.0.0",
+          "Pomelo.EntityFrameworkCore.MySql": "9.0.0",
+          "Swashbuckle.AspNetCore": "7.3.1"
+        },
+        "runtime": {
+          "Distribution.dll": {
+            "assemblyVersion": "1.0.0.0",
+            "fileVersion": "1.0.0.0"
+          }
+        }
+      }
+    }
+  },
+  "libraries": {
+    "Distribution.Tests/1.0.0": {
+      "type": "project",
+      "serviceable": false,
+      "sha512": ""
+    },
+    "Castle.Core/5.1.1": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-rpYtIczkzGpf+EkZgDr9CClTdemhsrwA/W5hMoPjLkRFnXzH44zDLoovXeKtmxb1ykXK9aJVODSpiJml8CTw2g==",
+      "path": "castle.core/5.1.1",
+      "hashPath": "castle.core.5.1.1.nupkg.sha512"
+    },
+    "Microsoft.AspNetCore.Authentication.JwtBearer/9.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-bs+1Pq3vQdS2lTyxNUd9fEhtMsq3eLUpK36k2t56iDMVrk6OrAoFtvrQrTK0Y0OetTcJrUkGU7hBlf+ORzHLqQ==",
+      "path": "microsoft.aspnetcore.authentication.jwtbearer/9.0.0",
+      "hashPath": "microsoft.aspnetcore.authentication.jwtbearer.9.0.0.nupkg.sha512"
+    },
+    "Microsoft.AspNetCore.OpenApi/9.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-FqUK5j1EOPNuFT7IafltZQ3cakqhSwVzH5ZW1MhZDe4pPXs9sJ2M5jom1Omsu+mwF2tNKKlRAzLRHQTZzbd+6Q==",
+      "path": "microsoft.aspnetcore.openapi/9.0.0",
+      "hashPath": "microsoft.aspnetcore.openapi.9.0.0.nupkg.sha512"
+    },
+    "Microsoft.CodeCoverage/17.12.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-4svMznBd5JM21JIG2xZKGNanAHNXplxf/kQDFfLHXQ3OnpJkayRK/TjacFjA+EYmoyuNXHo/sOETEfcYtAzIrA==",
+      "path": "microsoft.codecoverage/17.12.0",
+      "hashPath": "microsoft.codecoverage.17.12.0.nupkg.sha512"
+    },
+    "Microsoft.EntityFrameworkCore/9.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-wpG+nfnfDAw87R3ovAsUmjr3MZ4tYXf6bFqEPVAIKE6IfPml3DS//iX0DBnf8kWn5ZHSO5oi1m4d/Jf+1LifJQ==",
+      "path": "microsoft.entityframeworkcore/9.0.0",
+      "hashPath": "microsoft.entityframeworkcore.9.0.0.nupkg.sha512"
+    },
+    "Microsoft.EntityFrameworkCore.Abstractions/9.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-fnmifFL8KaA4ZNLCVgfjCWhZUFxkrDInx5hR4qG7Q8IEaSiy/6VOSRFyx55oH7MV4y7wM3J3EE90nSpcVBI44Q==",
+      "path": "microsoft.entityframeworkcore.abstractions/9.0.0",
+      "hashPath": "microsoft.entityframeworkcore.abstractions.9.0.0.nupkg.sha512"
+    },
+    "Microsoft.EntityFrameworkCore.Relational/9.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-j+msw6fWgAE9M3Q/5B9Uhv7pdAdAQUvFPJAiBJmoy+OXvehVbfbCE8ftMAa51Uo2ZeiqVnHShhnv4Y4UJJmUzA==",
+      "path": "microsoft.entityframeworkcore.relational/9.0.0",
+      "hashPath": "microsoft.entityframeworkcore.relational.9.0.0.nupkg.sha512"
+    },
+    "Microsoft.IdentityModel.Abstractions/8.0.1": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-OtlIWcyX01olfdevPKZdIPfBEvbcioDyBiE/Z2lHsopsMD7twcKtlN9kMevHmI5IIPhFpfwCIiR6qHQz1WHUIw==",
+      "path": "microsoft.identitymodel.abstractions/8.0.1",
+      "hashPath": "microsoft.identitymodel.abstractions.8.0.1.nupkg.sha512"
+    },
+    "Microsoft.IdentityModel.JsonWebTokens/8.0.1": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-s6++gF9x0rQApQzOBbSyp4jUaAlwm+DroKfL8gdOHxs83k8SJfUXhuc46rDB3rNXBQ1MVRxqKUrqFhO/M0E97g==",
+      "path": "microsoft.identitymodel.jsonwebtokens/8.0.1",
+      "hashPath": "microsoft.identitymodel.jsonwebtokens.8.0.1.nupkg.sha512"
+    },
+    "Microsoft.IdentityModel.Logging/8.0.1": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-UCPF2exZqBXe7v/6sGNiM6zCQOUXXQ9+v5VTb9gPB8ZSUPnX53BxlN78v2jsbIvK9Dq4GovQxo23x8JgWvm/Qg==",
+      "path": "microsoft.identitymodel.logging/8.0.1",
+      "hashPath": "microsoft.identitymodel.logging.8.0.1.nupkg.sha512"
+    },
+    "Microsoft.IdentityModel.Protocols/8.0.1": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-uA2vpKqU3I2mBBEaeJAWPTjT9v1TZrGWKdgK6G5qJd03CLx83kdiqO9cmiK8/n1erkHzFBwU/RphP83aAe3i3g==",
+      "path": "microsoft.identitymodel.protocols/8.0.1",
+      "hashPath": "microsoft.identitymodel.protocols.8.0.1.nupkg.sha512"
+    },
+    "Microsoft.IdentityModel.Protocols.OpenIdConnect/8.0.1": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-AQDbfpL+yzuuGhO/mQhKNsp44pm5Jv8/BI4KiFXR7beVGZoSH35zMV3PrmcfvSTsyI6qrcR898NzUauD6SRigg==",
+      "path": "microsoft.identitymodel.protocols.openidconnect/8.0.1",
+      "hashPath": "microsoft.identitymodel.protocols.openidconnect.8.0.1.nupkg.sha512"
+    },
+    "Microsoft.IdentityModel.Tokens/8.0.1": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-kDimB6Dkd3nkW2oZPDkMkVHfQt3IDqO5gL0oa8WVy3OP4uE8Ij+8TXnqg9TOd9ufjsY3IDiGz7pCUbnfL18tjg==",
+      "path": "microsoft.identitymodel.tokens/8.0.1",
+      "hashPath": "microsoft.identitymodel.tokens.8.0.1.nupkg.sha512"
+    },
+    "Microsoft.NET.Test.Sdk/17.12.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-kt/PKBZ91rFCWxVIJZSgVLk+YR+4KxTuHf799ho8WNiK5ZQpJNAEZCAWX86vcKrs+DiYjiibpYKdGZP6+/N17w==",
+      "path": "microsoft.net.test.sdk/17.12.0",
+      "hashPath": "microsoft.net.test.sdk.17.12.0.nupkg.sha512"
+    },
+    "Microsoft.OpenApi/1.6.22": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-aBvunmrdu/x+4CaA/UP1Jx4xWGwk4kymhoIRnn2Vp+zi5/KOPQJ9EkSXHRUr01WcGKtYl3Au7XfkPJbU1G2sjQ==",
+      "path": "microsoft.openapi/1.6.22",
+      "hashPath": "microsoft.openapi.1.6.22.nupkg.sha512"
+    },
+    "Microsoft.TestPlatform.ObjectModel/17.12.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-TDqkTKLfQuAaPcEb3pDDWnh7b3SyZF+/W9OZvWFp6eJCIiiYFdSB6taE2I6tWrFw5ywhzOb6sreoGJTI6m3rSQ==",
+      "path": "microsoft.testplatform.objectmodel/17.12.0",
+      "hashPath": "microsoft.testplatform.objectmodel.17.12.0.nupkg.sha512"
+    },
+    "Microsoft.TestPlatform.TestHost/17.12.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-MiPEJQNyADfwZ4pJNpQex+t9/jOClBGMiCiVVFuELCMSX2nmNfvUor3uFVxNNCg30uxDP8JDYfPnMXQzsfzYyg==",
+      "path": "microsoft.testplatform.testhost/17.12.0",
+      "hashPath": "microsoft.testplatform.testhost.17.12.0.nupkg.sha512"
+    },
+    "Moq/4.20.72": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-EA55cjyNn8eTNWrgrdZJH5QLFp2L43oxl1tlkoYUKIE9pRwL784OWiTXeCV5ApS+AMYEAlt7Fo03A2XfouvHmQ==",
+      "path": "moq/4.20.72",
+      "hashPath": "moq.4.20.72.nupkg.sha512"
+    },
+    "MySqlConnector/2.4.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-78M+gVOjbdZEDIyXQqcA7EYlCGS3tpbUELHvn6638A2w0pkPI625ixnzsa5staAd3N9/xFmPJtkKDYwsXpFi/w==",
+      "path": "mysqlconnector/2.4.0",
+      "hashPath": "mysqlconnector.2.4.0.nupkg.sha512"
+    },
+    "Newtonsoft.Json/13.0.1": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-ppPFpBcvxdsfUonNcvITKqLl3bqxWbDCZIzDWHzjpdAHRFfZe0Dw9HmA0+za13IdyrgJwpkDTDA9fHaxOrt20A==",
+      "path": "newtonsoft.json/13.0.1",
+      "hashPath": "newtonsoft.json.13.0.1.nupkg.sha512"
+    },
+    "Pomelo.EntityFrameworkCore.MySql/9.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-cl7S4s6CbJno0LjNxrBHNc2xxmCliR5i40ATPZk/eTywVaAbHCbdc9vbGc3QThvwGjHqrDHT8vY9m1VF/47o0g==",
+      "path": "pomelo.entityframeworkcore.mysql/9.0.0",
+      "hashPath": "pomelo.entityframeworkcore.mysql.9.0.0.nupkg.sha512"
+    },
+    "Swashbuckle.AspNetCore/7.3.1": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-6u8w+UXp/sF89xQjfydWw6znQrUpbpFOmEIs8ODE+S0bV+mCQ9dNP4mk+HRsGHylpDaP5KSYSCEfFSgluLXHsA==",
+      "path": "swashbuckle.aspnetcore/7.3.1",
+      "hashPath": "swashbuckle.aspnetcore.7.3.1.nupkg.sha512"
+    },
+    "Swashbuckle.AspNetCore.Swagger/7.3.1": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-jQuJ8kVbq+YE8WsJE3RwWHlF1kasp0QkA9Gl6NeNLICrhcgN8IQIthMufYW6t/4hpcN5cBIdES5jCEV81WjHbA==",
+      "path": "swashbuckle.aspnetcore.swagger/7.3.1",
+      "hashPath": "swashbuckle.aspnetcore.swagger.7.3.1.nupkg.sha512"
+    },
+    "Swashbuckle.AspNetCore.SwaggerGen/7.3.1": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-xs7Pznb3SSjZy7HpThE0ILqECfQFsGDHOrRoIYD/j67ktdRR1juDG4AMyidXXCOipgzHanZoF+nFrc+Nmjqjyw==",
+      "path": "swashbuckle.aspnetcore.swaggergen/7.3.1",
+      "hashPath": "swashbuckle.aspnetcore.swaggergen.7.3.1.nupkg.sha512"
+    },
+    "Swashbuckle.AspNetCore.SwaggerUI/7.3.1": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-hs6C+lmNEzipOA1WPQpIaGvvoXjUbnoevbv6l7o9ZQE8SNF8ggjOmK6NB6cYdMcEvk0uBeKl4Qq/BnRt5MFVqg==",
+      "path": "swashbuckle.aspnetcore.swaggerui/7.3.1",
+      "hashPath": "swashbuckle.aspnetcore.swaggerui.7.3.1.nupkg.sha512"
+    },
+    "System.IdentityModel.Tokens.Jwt/8.0.1": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-GJw3bYkWpOgvN3tJo5X4lYUeIFA2HD293FPUhKmp7qxS+g5ywAb34Dnd3cDAFLkcMohy5XTpoaZ4uAHuw0uSPQ==",
+      "path": "system.identitymodel.tokens.jwt/8.0.1",
+      "hashPath": "system.identitymodel.tokens.jwt.8.0.1.nupkg.sha512"
+    },
+    "xunit/2.9.3": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-TlXQBinK35LpOPKHAqbLY4xlEen9TBafjs0V5KnA4wZsoQLQJiirCR4CbIXvOH8NzkW4YeJKP5P/Bnrodm0h9Q==",
+      "path": "xunit/2.9.3",
+      "hashPath": "xunit.2.9.3.nupkg.sha512"
+    },
+    "xunit.abstractions/2.0.3": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-pot1I4YOxlWjIb5jmwvvQNbTrZ3lJQ+jUGkGjWE3hEFM0l5gOnBWS+H3qsex68s5cO52g+44vpGzhAt+42vwKg==",
+      "path": "xunit.abstractions/2.0.3",
+      "hashPath": "xunit.abstractions.2.0.3.nupkg.sha512"
+    },
+    "xunit.assert/2.9.3": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-/Kq28fCE7MjOV42YLVRAJzRF0WmEqsmflm0cfpMjGtzQ2lR5mYVj1/i0Y8uDAOLczkL3/jArrwehfMD0YogMAA==",
+      "path": "xunit.assert/2.9.3",
+      "hashPath": "xunit.assert.2.9.3.nupkg.sha512"
+    },
+    "xunit.core/2.9.3": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-BiAEvqGvyme19wE0wTKdADH+NloYqikiU0mcnmiNyXaF9HyHmE6sr/3DC5vnBkgsWaE6yPyWszKSPSApWdRVeQ==",
+      "path": "xunit.core/2.9.3",
+      "hashPath": "xunit.core.2.9.3.nupkg.sha512"
+    },
+    "xunit.extensibility.core/2.9.3": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-kf3si0YTn2a8J8eZNb+zFpwfoyvIrQ7ivNk5ZYA5yuYk1bEtMe4DxJ2CF/qsRgmEnDr7MnW1mxylBaHTZ4qErA==",
+      "path": "xunit.extensibility.core/2.9.3",
+      "hashPath": "xunit.extensibility.core.2.9.3.nupkg.sha512"
+    },
+    "xunit.extensibility.execution/2.9.3": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-yMb6vMESlSrE3Wfj7V6cjQ3S4TXdXpRqYeNEI3zsX31uTsGMJjEw6oD5F5u1cHnMptjhEECnmZSsPxB6ChZHDQ==",
+      "path": "xunit.extensibility.execution/2.9.3",
+      "hashPath": "xunit.extensibility.execution.2.9.3.nupkg.sha512"
+    },
+    "Distribution/1.0.0": {
+      "type": "project",
+      "serviceable": false,
+      "sha512": ""
+    }
+  }
+}

Distribution.Tests/bin/Debug/net9.0/Distribution.Tests.runtimeconfig.json

@@ -0,0 +1,19 @@
+{
+  "runtimeOptions": {
+    "tfm": "net9.0",
+    "frameworks": [
+      {
+        "name": "Microsoft.NETCore.App",
+        "version": "9.0.0"
+      },
+      {
+        "name": "Microsoft.AspNetCore.App",
+        "version": "9.0.0"
+      }
+    ],
+    "configProperties": {
+      "System.Reflection.NullabilityInfoContext.IsSupported": true,
+      "System.Runtime.Serialization.EnableUnsafeBinaryFormatterSerialization": false
+    }
+  }
+}

Distribution.Tests/bin/Debug/net9.0/Distribution.deps.json

@@ -0,0 +1,879 @@
+{
+  "runtimeTarget": {
+    "name": ".NETCoreApp,Version=v9.0",
+    "signature": ""
+  },
+  "compilationOptions": {},
+  "targets": {
+    ".NETCoreApp,Version=v9.0": {
+      "Distribution/1.0.0": {
+        "dependencies": {
+          "Microsoft.AspNetCore.Authentication.JwtBearer": "9.0.0",
+          "Microsoft.AspNetCore.OpenApi": "9.0.0",
+          "Microsoft.EntityFrameworkCore.Design": "9.0.0",
+          "Pomelo.EntityFrameworkCore.MySql": "9.0.0",
+          "Swashbuckle.AspNetCore": "7.3.1"
+        },
+        "runtime": {
+          "Distribution.dll": {}
+        }
+      },
+      "Humanizer.Core/2.14.1": {
+        "runtime": {
+          "lib/net6.0/Humanizer.dll": {
+            "assemblyVersion": "2.14.0.0",
+            "fileVersion": "2.14.1.48190"
+          }
+        }
+      },
+      "Microsoft.AspNetCore.Authentication.JwtBearer/9.0.0": {
+        "dependencies": {
+          "Microsoft.IdentityModel.Protocols.OpenIdConnect": "8.0.1"
+        },
+        "runtime": {
+          "lib/net9.0/Microsoft.AspNetCore.Authentication.JwtBearer.dll": {
+            "assemblyVersion": "9.0.0.0",
+            "fileVersion": "9.0.24.52903"
+          }
+        }
+      },
+      "Microsoft.AspNetCore.OpenApi/9.0.0": {
+        "dependencies": {
+          "Microsoft.OpenApi": "1.6.22"
+        },
+        "runtime": {
+          "lib/net9.0/Microsoft.AspNetCore.OpenApi.dll": {
+            "assemblyVersion": "9.0.0.0",
+            "fileVersion": "9.0.24.52903"
+          }
+        }
+      },
+      "Microsoft.Bcl.AsyncInterfaces/7.0.0": {
+        "runtime": {
+          "lib/netstandard2.1/Microsoft.Bcl.AsyncInterfaces.dll": {
+            "assemblyVersion": "7.0.0.0",
+            "fileVersion": "7.0.22.51805"
+          }
+        }
+      },
+      "Microsoft.Build.Locator/1.7.8": {
+        "runtime": {
+          "lib/net6.0/Microsoft.Build.Locator.dll": {
+            "assemblyVersion": "1.0.0.0",
+            "fileVersion": "1.7.8.28074"
+          }
+        }
+      },
+      "Microsoft.CodeAnalysis.Common/4.8.0": {
+        "runtime": {
+          "lib/net7.0/Microsoft.CodeAnalysis.dll": {
+            "assemblyVersion": "4.8.0.0",
+            "fileVersion": "4.800.23.55801"
+          }
+        },
+        "resources": {
+          "lib/net7.0/cs/Microsoft.CodeAnalysis.resources.dll": {
+            "locale": "cs"
+          },
+          "lib/net7.0/de/Microsoft.CodeAnalysis.resources.dll": {
+            "locale": "de"
+          },
+          "lib/net7.0/es/Microsoft.CodeAnalysis.resources.dll": {
+            "locale": "es"
+          },
+          "lib/net7.0/fr/Microsoft.CodeAnalysis.resources.dll": {
+            "locale": "fr"
+          },
+          "lib/net7.0/it/Microsoft.CodeAnalysis.resources.dll": {
+            "locale": "it"
+          },
+          "lib/net7.0/ja/Microsoft.CodeAnalysis.resources.dll": {
+            "locale": "ja"
+          },
+          "lib/net7.0/ko/Microsoft.CodeAnalysis.resources.dll": {
+            "locale": "ko"
+          },
+          "lib/net7.0/pl/Microsoft.CodeAnalysis.resources.dll": {
+            "locale": "pl"
+          },
+          "lib/net7.0/pt-BR/Microsoft.CodeAnalysis.resources.dll": {
+            "locale": "pt-BR"
+          },
+          "lib/net7.0/ru/Microsoft.CodeAnalysis.resources.dll": {
+            "locale": "ru"
+          },
+          "lib/net7.0/tr/Microsoft.CodeAnalysis.resources.dll": {
+            "locale": "tr"
+          },
+          "lib/net7.0/zh-Hans/Microsoft.CodeAnalysis.resources.dll": {
+            "locale": "zh-Hans"
+          },
+          "lib/net7.0/zh-Hant/Microsoft.CodeAnalysis.resources.dll": {
+            "locale": "zh-Hant"
+          }
+        }
+      },
+      "Microsoft.CodeAnalysis.CSharp/4.8.0": {
+        "dependencies": {
+          "Microsoft.CodeAnalysis.Common": "4.8.0"
+        },
+        "runtime": {
+          "lib/net7.0/Microsoft.CodeAnalysis.CSharp.dll": {
+            "assemblyVersion": "4.8.0.0",
+            "fileVersion": "4.800.23.55801"
+          }
+        },
+        "resources": {
+          "lib/net7.0/cs/Microsoft.CodeAnalysis.CSharp.resources.dll": {
+            "locale": "cs"
+          },
+          "lib/net7.0/de/Microsoft.CodeAnalysis.CSharp.resources.dll": {
+            "locale": "de"
+          },
+          "lib/net7.0/es/Microsoft.CodeAnalysis.CSharp.resources.dll": {
+            "locale": "es"
+          },
+          "lib/net7.0/fr/Microsoft.CodeAnalysis.CSharp.resources.dll": {
+            "locale": "fr"
+          },
+          "lib/net7.0/it/Microsoft.CodeAnalysis.CSharp.resources.dll": {
+            "locale": "it"
+          },
+          "lib/net7.0/ja/Microsoft.CodeAnalysis.CSharp.resources.dll": {
+            "locale": "ja"
+          },
+          "lib/net7.0/ko/Microsoft.CodeAnalysis.CSharp.resources.dll": {
+            "locale": "ko"
+          },
+          "lib/net7.0/pl/Microsoft.CodeAnalysis.CSharp.resources.dll": {
+            "locale": "pl"
+          },
+          "lib/net7.0/pt-BR/Microsoft.CodeAnalysis.CSharp.resources.dll": {
+            "locale": "pt-BR"
+          },
+          "lib/net7.0/ru/Microsoft.CodeAnalysis.CSharp.resources.dll": {
+            "locale": "ru"
+          },
+          "lib/net7.0/tr/Microsoft.CodeAnalysis.CSharp.resources.dll": {
+            "locale": "tr"
+          },
+          "lib/net7.0/zh-Hans/Microsoft.CodeAnalysis.CSharp.resources.dll": {
+            "locale": "zh-Hans"
+          },
+          "lib/net7.0/zh-Hant/Microsoft.CodeAnalysis.CSharp.resources.dll": {
+            "locale": "zh-Hant"
+          }
+        }
+      },
+      "Microsoft.CodeAnalysis.CSharp.Workspaces/4.8.0": {
+        "dependencies": {
+          "Humanizer.Core": "2.14.1",
+          "Microsoft.CodeAnalysis.CSharp": "4.8.0",
+          "Microsoft.CodeAnalysis.Common": "4.8.0",
+          "Microsoft.CodeAnalysis.Workspaces.Common": "4.8.0"
+        },
+        "runtime": {
+          "lib/net7.0/Microsoft.CodeAnalysis.CSharp.Workspaces.dll": {
+            "assemblyVersion": "4.8.0.0",
+            "fileVersion": "4.800.23.55801"
+          }
+        },
+        "resources": {
+          "lib/net7.0/cs/Microsoft.CodeAnalysis.CSharp.Workspaces.resources.dll": {
+            "locale": "cs"
+          },
+          "lib/net7.0/de/Microsoft.CodeAnalysis.CSharp.Workspaces.resources.dll": {
+            "locale": "de"
+          },
+          "lib/net7.0/es/Microsoft.CodeAnalysis.CSharp.Workspaces.resources.dll": {
+            "locale": "es"
+          },
+          "lib/net7.0/fr/Microsoft.CodeAnalysis.CSharp.Workspaces.resources.dll": {
+            "locale": "fr"
+          },
+          "lib/net7.0/it/Microsoft.CodeAnalysis.CSharp.Workspaces.resources.dll": {
+            "locale": "it"
+          },
+          "lib/net7.0/ja/Microsoft.CodeAnalysis.CSharp.Workspaces.resources.dll": {
+            "locale": "ja"
+          },
+          "lib/net7.0/ko/Microsoft.CodeAnalysis.CSharp.Workspaces.resources.dll": {
+            "locale": "ko"
+          },
+          "lib/net7.0/pl/Microsoft.CodeAnalysis.CSharp.Workspaces.resources.dll": {
+            "locale": "pl"
+          },
+          "lib/net7.0/pt-BR/Microsoft.CodeAnalysis.CSharp.Workspaces.resources.dll": {
+            "locale": "pt-BR"
+          },
+          "lib/net7.0/ru/Microsoft.CodeAnalysis.CSharp.Workspaces.resources.dll": {
+            "locale": "ru"
+          },
+          "lib/net7.0/tr/Microsoft.CodeAnalysis.CSharp.Workspaces.resources.dll": {
+            "locale": "tr"
+          },
+          "lib/net7.0/zh-Hans/Microsoft.CodeAnalysis.CSharp.Workspaces.resources.dll": {
+            "locale": "zh-Hans"
+          },
+          "lib/net7.0/zh-Hant/Microsoft.CodeAnalysis.CSharp.Workspaces.resources.dll": {
+            "locale": "zh-Hant"
+          }
+        }
+      },
+      "Microsoft.CodeAnalysis.Workspaces.Common/4.8.0": {
+        "dependencies": {
+          "Humanizer.Core": "2.14.1",
+          "Microsoft.Bcl.AsyncInterfaces": "7.0.0",
+          "Microsoft.CodeAnalysis.Common": "4.8.0",
+          "System.Composition": "7.0.0"
+        },
+        "runtime": {
+          "lib/net7.0/Microsoft.CodeAnalysis.Workspaces.dll": {
+            "assemblyVersion": "4.8.0.0",
+            "fileVersion": "4.800.23.55801"
+          }
+        },
+        "resources": {
+          "lib/net7.0/cs/Microsoft.CodeAnalysis.Workspaces.resources.dll": {
+            "locale": "cs"
+          },
+          "lib/net7.0/de/Microsoft.CodeAnalysis.Workspaces.resources.dll": {
+            "locale": "de"
+          },
+          "lib/net7.0/es/Microsoft.CodeAnalysis.Workspaces.resources.dll": {
+            "locale": "es"
+          },
+          "lib/net7.0/fr/Microsoft.CodeAnalysis.Workspaces.resources.dll": {
+            "locale": "fr"
+          },
+          "lib/net7.0/it/Microsoft.CodeAnalysis.Workspaces.resources.dll": {
+            "locale": "it"
+          },
+          "lib/net7.0/ja/Microsoft.CodeAnalysis.Workspaces.resources.dll": {
+            "locale": "ja"
+          },
+          "lib/net7.0/ko/Microsoft.CodeAnalysis.Workspaces.resources.dll": {
+            "locale": "ko"
+          },
+          "lib/net7.0/pl/Microsoft.CodeAnalysis.Workspaces.resources.dll": {
+            "locale": "pl"
+          },
+          "lib/net7.0/pt-BR/Microsoft.CodeAnalysis.Workspaces.resources.dll": {
+            "locale": "pt-BR"
+          },
+          "lib/net7.0/ru/Microsoft.CodeAnalysis.Workspaces.resources.dll": {
+            "locale": "ru"
+          },
+          "lib/net7.0/tr/Microsoft.CodeAnalysis.Workspaces.resources.dll": {
+            "locale": "tr"
+          },
+          "lib/net7.0/zh-Hans/Microsoft.CodeAnalysis.Workspaces.resources.dll": {
+            "locale": "zh-Hans"
+          },
+          "lib/net7.0/zh-Hant/Microsoft.CodeAnalysis.Workspaces.resources.dll": {
+            "locale": "zh-Hant"
+          }
+        }
+      },
+      "Microsoft.CodeAnalysis.Workspaces.MSBuild/4.8.0": {
+        "dependencies": {
+          "Microsoft.CodeAnalysis.Common": "4.8.0",
+          "Microsoft.CodeAnalysis.Workspaces.Common": "4.8.0"
+        },
+        "runtime": {
+          "lib/net7.0/Microsoft.CodeAnalysis.Workspaces.MSBuild.BuildHost.dll": {
+            "assemblyVersion": "4.8.0.0",
+            "fileVersion": "4.800.23.55801"
+          },
+          "lib/net7.0/Microsoft.CodeAnalysis.Workspaces.MSBuild.dll": {
+            "assemblyVersion": "4.8.0.0",
+            "fileVersion": "4.800.23.55801"
+          }
+        },
+        "resources": {
+          "lib/net7.0/cs/Microsoft.CodeAnalysis.Workspaces.MSBuild.BuildHost.resources.dll": {
+            "locale": "cs"
+          },
+          "lib/net7.0/de/Microsoft.CodeAnalysis.Workspaces.MSBuild.BuildHost.resources.dll": {
+            "locale": "de"
+          },
+          "lib/net7.0/es/Microsoft.CodeAnalysis.Workspaces.MSBuild.BuildHost.resources.dll": {
+            "locale": "es"
+          },
+          "lib/net7.0/fr/Microsoft.CodeAnalysis.Workspaces.MSBuild.BuildHost.resources.dll": {
+            "locale": "fr"
+          },
+          "lib/net7.0/it/Microsoft.CodeAnalysis.Workspaces.MSBuild.BuildHost.resources.dll": {
+            "locale": "it"
+          },
+          "lib/net7.0/ja/Microsoft.CodeAnalysis.Workspaces.MSBuild.BuildHost.resources.dll": {
+            "locale": "ja"
+          },
+          "lib/net7.0/ko/Microsoft.CodeAnalysis.Workspaces.MSBuild.BuildHost.resources.dll": {
+            "locale": "ko"
+          },
+          "lib/net7.0/pl/Microsoft.CodeAnalysis.Workspaces.MSBuild.BuildHost.resources.dll": {
+            "locale": "pl"
+          },
+          "lib/net7.0/pt-BR/Microsoft.CodeAnalysis.Workspaces.MSBuild.BuildHost.resources.dll": {
+            "locale": "pt-BR"
+          },
+          "lib/net7.0/ru/Microsoft.CodeAnalysis.Workspaces.MSBuild.BuildHost.resources.dll": {
+            "locale": "ru"
+          },
+          "lib/net7.0/tr/Microsoft.CodeAnalysis.Workspaces.MSBuild.BuildHost.resources.dll": {
+            "locale": "tr"
+          },
+          "lib/net7.0/zh-Hans/Microsoft.CodeAnalysis.Workspaces.MSBuild.BuildHost.resources.dll": {
+            "locale": "zh-Hans"
+          },
+          "lib/net7.0/zh-Hant/Microsoft.CodeAnalysis.Workspaces.MSBuild.BuildHost.resources.dll": {
+            "locale": "zh-Hant"
+          }
+        }
+      },
+      "Microsoft.EntityFrameworkCore/9.0.0": {
+        "dependencies": {
+          "Microsoft.EntityFrameworkCore.Abstractions": "9.0.0"
+        },
+        "runtime": {
+          "lib/net8.0/Microsoft.EntityFrameworkCore.dll": {
+            "assemblyVersion": "9.0.0.0",
+            "fileVersion": "9.0.24.52902"
+          }
+        }
+      },
+      "Microsoft.EntityFrameworkCore.Abstractions/9.0.0": {
+        "runtime": {
+          "lib/net8.0/Microsoft.EntityFrameworkCore.Abstractions.dll": {
+            "assemblyVersion": "9.0.0.0",
+            "fileVersion": "9.0.24.52902"
+          }
+        }
+      },
+      "Microsoft.EntityFrameworkCore.Design/9.0.0": {
+        "dependencies": {
+          "Humanizer.Core": "2.14.1",
+          "Microsoft.Build.Locator": "1.7.8",
+          "Microsoft.CodeAnalysis.CSharp": "4.8.0",
+          "Microsoft.CodeAnalysis.CSharp.Workspaces": "4.8.0",
+          "Microsoft.CodeAnalysis.Workspaces.MSBuild": "4.8.0",
+          "Microsoft.EntityFrameworkCore.Relational": "9.0.0",
+          "Microsoft.Extensions.DependencyModel": "9.0.0",
+          "Mono.TextTemplating": "3.0.0"
+        },
+        "runtime": {
+          "lib/net8.0/Microsoft.EntityFrameworkCore.Design.dll": {
+            "assemblyVersion": "9.0.0.0",
+            "fileVersion": "9.0.24.52902"
+          }
+        }
+      },
+      "Microsoft.EntityFrameworkCore.Relational/9.0.0": {
+        "dependencies": {
+          "Microsoft.EntityFrameworkCore": "9.0.0"
+        },
+        "runtime": {
+          "lib/net8.0/Microsoft.EntityFrameworkCore.Relational.dll": {
+            "assemblyVersion": "9.0.0.0",
+            "fileVersion": "9.0.24.52902"
+          }
+        }
+      },
+      "Microsoft.Extensions.DependencyModel/9.0.0": {
+        "runtime": {
+          "lib/net9.0/Microsoft.Extensions.DependencyModel.dll": {
+            "assemblyVersion": "9.0.0.0",
+            "fileVersion": "9.0.24.52809"
+          }
+        }
+      },
+      "Microsoft.IdentityModel.Abstractions/8.0.1": {
+        "runtime": {
+          "lib/net9.0/Microsoft.IdentityModel.Abstractions.dll": {
+            "assemblyVersion": "8.0.1.0",
+            "fileVersion": "8.0.1.50722"
+          }
+        }
+      },
+      "Microsoft.IdentityModel.JsonWebTokens/8.0.1": {
+        "dependencies": {
+          "Microsoft.IdentityModel.Tokens": "8.0.1"
+        },
+        "runtime": {
+          "lib/net9.0/Microsoft.IdentityModel.JsonWebTokens.dll": {
+            "assemblyVersion": "8.0.1.0",
+            "fileVersion": "8.0.1.50722"
+          }
+        }
+      },
+      "Microsoft.IdentityModel.Logging/8.0.1": {
+        "dependencies": {
+          "Microsoft.IdentityModel.Abstractions": "8.0.1"
+        },
+        "runtime": {
+          "lib/net9.0/Microsoft.IdentityModel.Logging.dll": {
+            "assemblyVersion": "8.0.1.0",
+            "fileVersion": "8.0.1.50722"
+          }
+        }
+      },
+      "Microsoft.IdentityModel.Protocols/8.0.1": {
+        "dependencies": {
+          "Microsoft.IdentityModel.Tokens": "8.0.1"
+        },
+        "runtime": {
+          "lib/net9.0/Microsoft.IdentityModel.Protocols.dll": {
+            "assemblyVersion": "8.0.1.0",
+            "fileVersion": "8.0.1.50722"
+          }
+        }
+      },
+      "Microsoft.IdentityModel.Protocols.OpenIdConnect/8.0.1": {
+        "dependencies": {
+          "Microsoft.IdentityModel.Protocols": "8.0.1",
+          "System.IdentityModel.Tokens.Jwt": "8.0.1"
+        },
+        "runtime": {
+          "lib/net9.0/Microsoft.IdentityModel.Protocols.OpenIdConnect.dll": {
+            "assemblyVersion": "8.0.1.0",
+            "fileVersion": "8.0.1.50722"
+          }
+        }
+      },
+      "Microsoft.IdentityModel.Tokens/8.0.1": {
+        "dependencies": {
+          "Microsoft.IdentityModel.Logging": "8.0.1"
+        },
+        "runtime": {
+          "lib/net9.0/Microsoft.IdentityModel.Tokens.dll": {
+            "assemblyVersion": "8.0.1.0",
+            "fileVersion": "8.0.1.50722"
+          }
+        }
+      },
+      "Microsoft.OpenApi/1.6.22": {
+        "runtime": {
+          "lib/netstandard2.0/Microsoft.OpenApi.dll": {
+            "assemblyVersion": "1.6.22.0",
+            "fileVersion": "1.6.22.0"
+          }
+        }
+      },
+      "Mono.TextTemplating/3.0.0": {
+        "dependencies": {
+          "System.CodeDom": "6.0.0"
+        },
+        "runtime": {
+          "lib/net6.0/Mono.TextTemplating.dll": {
+            "assemblyVersion": "3.0.0.0",
+            "fileVersion": "3.0.0.1"
+          }
+        }
+      },
+      "MySqlConnector/2.4.0": {
+        "runtime": {
+          "lib/net9.0/MySqlConnector.dll": {
+            "assemblyVersion": "2.0.0.0",
+            "fileVersion": "2.4.0.0"
+          }
+        }
+      },
+      "Pomelo.EntityFrameworkCore.MySql/9.0.0": {
+        "dependencies": {
+          "Microsoft.EntityFrameworkCore.Relational": "9.0.0",
+          "MySqlConnector": "2.4.0"
+        },
+        "runtime": {
+          "lib/net8.0/Pomelo.EntityFrameworkCore.MySql.dll": {
+            "assemblyVersion": "9.0.0.0",
+            "fileVersion": "9.0.0.0"
+          }
+        }
+      },
+      "Swashbuckle.AspNetCore/7.3.1": {
+        "dependencies": {
+          "Swashbuckle.AspNetCore.Swagger": "7.3.1",
+          "Swashbuckle.AspNetCore.SwaggerGen": "7.3.1",
+          "Swashbuckle.AspNetCore.SwaggerUI": "7.3.1"
+        }
+      },
+      "Swashbuckle.AspNetCore.Swagger/7.3.1": {
+        "dependencies": {
+          "Microsoft.OpenApi": "1.6.22"
+        },
+        "runtime": {
+          "lib/net9.0/Swashbuckle.AspNetCore.Swagger.dll": {
+            "assemblyVersion": "7.3.1.0",
+            "fileVersion": "7.3.1.1111"
+          }
+        }
+      },
+      "Swashbuckle.AspNetCore.SwaggerGen/7.3.1": {
+        "dependencies": {
+          "Swashbuckle.AspNetCore.Swagger": "7.3.1"
+        },
+        "runtime": {
+          "lib/net9.0/Swashbuckle.AspNetCore.SwaggerGen.dll": {
+            "assemblyVersion": "7.3.1.0",
+            "fileVersion": "7.3.1.1111"
+          }
+        }
+      },
+      "Swashbuckle.AspNetCore.SwaggerUI/7.3.1": {
+        "runtime": {
+          "lib/net9.0/Swashbuckle.AspNetCore.SwaggerUI.dll": {
+            "assemblyVersion": "7.3.1.0",
+            "fileVersion": "7.3.1.1111"
+          }
+        }
+      },
+      "System.CodeDom/6.0.0": {
+        "runtime": {
+          "lib/net6.0/System.CodeDom.dll": {
+            "assemblyVersion": "6.0.0.0",
+            "fileVersion": "6.0.21.52210"
+          }
+        }
+      },
+      "System.Composition/7.0.0": {
+        "dependencies": {
+          "System.Composition.AttributedModel": "7.0.0",
+          "System.Composition.Convention": "7.0.0",
+          "System.Composition.Hosting": "7.0.0",
+          "System.Composition.Runtime": "7.0.0",
+          "System.Composition.TypedParts": "7.0.0"
+        }
+      },
+      "System.Composition.AttributedModel/7.0.0": {
+        "runtime": {
+          "lib/net7.0/System.Composition.AttributedModel.dll": {
+            "assemblyVersion": "7.0.0.0",
+            "fileVersion": "7.0.22.51805"
+          }
+        }
+      },
+      "System.Composition.Convention/7.0.0": {
+        "dependencies": {
+          "System.Composition.AttributedModel": "7.0.0"
+        },
+        "runtime": {
+          "lib/net7.0/System.Composition.Convention.dll": {
+            "assemblyVersion": "7.0.0.0",
+            "fileVersion": "7.0.22.51805"
+          }
+        }
+      },
+      "System.Composition.Hosting/7.0.0": {
+        "dependencies": {
+          "System.Composition.Runtime": "7.0.0"
+        },
+        "runtime": {
+          "lib/net7.0/System.Composition.Hosting.dll": {
+            "assemblyVersion": "7.0.0.0",
+            "fileVersion": "7.0.22.51805"
+          }
+        }
+      },
+      "System.Composition.Runtime/7.0.0": {
+        "runtime": {
+          "lib/net7.0/System.Composition.Runtime.dll": {
+            "assemblyVersion": "7.0.0.0",
+            "fileVersion": "7.0.22.51805"
+          }
+        }
+      },
+      "System.Composition.TypedParts/7.0.0": {
+        "dependencies": {
+          "System.Composition.AttributedModel": "7.0.0",
+          "System.Composition.Hosting": "7.0.0",
+          "System.Composition.Runtime": "7.0.0"
+        },
+        "runtime": {
+          "lib/net7.0/System.Composition.TypedParts.dll": {
+            "assemblyVersion": "7.0.0.0",
+            "fileVersion": "7.0.22.51805"
+          }
+        }
+      },
+      "System.IdentityModel.Tokens.Jwt/8.0.1": {
+        "dependencies": {
+          "Microsoft.IdentityModel.JsonWebTokens": "8.0.1",
+          "Microsoft.IdentityModel.Tokens": "8.0.1"
+        },
+        "runtime": {
+          "lib/net9.0/System.IdentityModel.Tokens.Jwt.dll": {
+            "assemblyVersion": "8.0.1.0",
+            "fileVersion": "8.0.1.50722"
+          }
+        }
+      }
+    }
+  },
+  "libraries": {
+    "Distribution/1.0.0": {
+      "type": "project",
+      "serviceable": false,
+      "sha512": ""
+    },
+    "Humanizer.Core/2.14.1": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-lQKvtaTDOXnoVJ20ibTuSIOf2i0uO0MPbDhd1jm238I+U/2ZnRENj0cktKZhtchBMtCUSRQ5v4xBCUbKNmyVMw==",
+      "path": "humanizer.core/2.14.1",
+      "hashPath": "humanizer.core.2.14.1.nupkg.sha512"
+    },
+    "Microsoft.AspNetCore.Authentication.JwtBearer/9.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-bs+1Pq3vQdS2lTyxNUd9fEhtMsq3eLUpK36k2t56iDMVrk6OrAoFtvrQrTK0Y0OetTcJrUkGU7hBlf+ORzHLqQ==",
+      "path": "microsoft.aspnetcore.authentication.jwtbearer/9.0.0",
+      "hashPath": "microsoft.aspnetcore.authentication.jwtbearer.9.0.0.nupkg.sha512"
+    },
+    "Microsoft.AspNetCore.OpenApi/9.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-FqUK5j1EOPNuFT7IafltZQ3cakqhSwVzH5ZW1MhZDe4pPXs9sJ2M5jom1Omsu+mwF2tNKKlRAzLRHQTZzbd+6Q==",
+      "path": "microsoft.aspnetcore.openapi/9.0.0",
+      "hashPath": "microsoft.aspnetcore.openapi.9.0.0.nupkg.sha512"
+    },
+    "Microsoft.Bcl.AsyncInterfaces/7.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-3aeMZ1N0lJoSyzqiP03hqemtb1BijhsJADdobn/4nsMJ8V1H+CrpuduUe4hlRdx+ikBQju1VGjMD1GJ3Sk05Eg==",
+      "path": "microsoft.bcl.asyncinterfaces/7.0.0",
+      "hashPath": "microsoft.bcl.asyncinterfaces.7.0.0.nupkg.sha512"
+    },
+    "Microsoft.Build.Locator/1.7.8": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-sPy10x527Ph16S2u0yGME4S6ohBKJ69WfjeGG/bvELYeZVmJdKjxgnlL8cJJJLGV/cZIRqSfB12UDB8ICakOog==",
+      "path": "microsoft.build.locator/1.7.8",
+      "hashPath": "microsoft.build.locator.1.7.8.nupkg.sha512"
+    },
+    "Microsoft.CodeAnalysis.Common/4.8.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-/jR+e/9aT+BApoQJABlVCKnnggGQbvGh7BKq2/wI1LamxC+LbzhcLj4Vj7gXCofl1n4E521YfF9w0WcASGg/KA==",
+      "path": "microsoft.codeanalysis.common/4.8.0",
+      "hashPath": "microsoft.codeanalysis.common.4.8.0.nupkg.sha512"
+    },
+    "Microsoft.CodeAnalysis.CSharp/4.8.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-+3+qfdb/aaGD8PZRCrsdobbzGs1m9u119SkkJt8e/mk3xLJz/udLtS2T6nY27OTXxBBw10HzAbC8Z9w08VyP/g==",
+      "path": "microsoft.codeanalysis.csharp/4.8.0",
+      "hashPath": "microsoft.codeanalysis.csharp.4.8.0.nupkg.sha512"
+    },
+    "Microsoft.CodeAnalysis.CSharp.Workspaces/4.8.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-3amm4tq4Lo8/BGvg9p3BJh3S9nKq2wqCXfS7138i69TUpo/bD+XvD0hNurpEBtcNZhi1FyutiomKJqVF39ugYA==",
+      "path": "microsoft.codeanalysis.csharp.workspaces/4.8.0",
+      "hashPath": "microsoft.codeanalysis.csharp.workspaces.4.8.0.nupkg.sha512"
+    },
+    "Microsoft.CodeAnalysis.Workspaces.Common/4.8.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-LXyV+MJKsKRu3FGJA3OmSk40OUIa/dQCFLOnm5X8MNcujx7hzGu8o+zjXlb/cy5xUdZK2UKYb9YaQ2E8m9QehQ==",
+      "path": "microsoft.codeanalysis.workspaces.common/4.8.0",
+      "hashPath": "microsoft.codeanalysis.workspaces.common.4.8.0.nupkg.sha512"
+    },
+    "Microsoft.CodeAnalysis.Workspaces.MSBuild/4.8.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-IEYreI82QZKklp54yPHxZNG9EKSK6nHEkeuf+0Asie9llgS1gp0V1hw7ODG+QyoB7MuAnNQHmeV1Per/ECpv6A==",
+      "path": "microsoft.codeanalysis.workspaces.msbuild/4.8.0",
+      "hashPath": "microsoft.codeanalysis.workspaces.msbuild.4.8.0.nupkg.sha512"
+    },
+    "Microsoft.EntityFrameworkCore/9.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-wpG+nfnfDAw87R3ovAsUmjr3MZ4tYXf6bFqEPVAIKE6IfPml3DS//iX0DBnf8kWn5ZHSO5oi1m4d/Jf+1LifJQ==",
+      "path": "microsoft.entityframeworkcore/9.0.0",
+      "hashPath": "microsoft.entityframeworkcore.9.0.0.nupkg.sha512"
+    },
+    "Microsoft.EntityFrameworkCore.Abstractions/9.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-fnmifFL8KaA4ZNLCVgfjCWhZUFxkrDInx5hR4qG7Q8IEaSiy/6VOSRFyx55oH7MV4y7wM3J3EE90nSpcVBI44Q==",
+      "path": "microsoft.entityframeworkcore.abstractions/9.0.0",
+      "hashPath": "microsoft.entityframeworkcore.abstractions.9.0.0.nupkg.sha512"
+    },
+    "Microsoft.EntityFrameworkCore.Design/9.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-Pqo8I+yHJ3VQrAoY0hiSncf+5P7gN/RkNilK5e+/K/yKh+yAWxdUAI6t0TG26a9VPlCa9FhyklzyFvRyj3YG9A==",
+      "path": "microsoft.entityframeworkcore.design/9.0.0",
+      "hashPath": "microsoft.entityframeworkcore.design.9.0.0.nupkg.sha512"
+    },
+    "Microsoft.EntityFrameworkCore.Relational/9.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-j+msw6fWgAE9M3Q/5B9Uhv7pdAdAQUvFPJAiBJmoy+OXvehVbfbCE8ftMAa51Uo2ZeiqVnHShhnv4Y4UJJmUzA==",
+      "path": "microsoft.entityframeworkcore.relational/9.0.0",
+      "hashPath": "microsoft.entityframeworkcore.relational.9.0.0.nupkg.sha512"
+    },
+    "Microsoft.Extensions.DependencyModel/9.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-saxr2XzwgDU77LaQfYFXmddEDRUKHF4DaGMZkNB3qjdVSZlax3//dGJagJkKrGMIPNZs2jVFXITyCCR6UHJNdA==",
+      "path": "microsoft.extensions.dependencymodel/9.0.0",
+      "hashPath": "microsoft.extensions.dependencymodel.9.0.0.nupkg.sha512"
+    },
+    "Microsoft.IdentityModel.Abstractions/8.0.1": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-OtlIWcyX01olfdevPKZdIPfBEvbcioDyBiE/Z2lHsopsMD7twcKtlN9kMevHmI5IIPhFpfwCIiR6qHQz1WHUIw==",
+      "path": "microsoft.identitymodel.abstractions/8.0.1",
+      "hashPath": "microsoft.identitymodel.abstractions.8.0.1.nupkg.sha512"
+    },
+    "Microsoft.IdentityModel.JsonWebTokens/8.0.1": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-s6++gF9x0rQApQzOBbSyp4jUaAlwm+DroKfL8gdOHxs83k8SJfUXhuc46rDB3rNXBQ1MVRxqKUrqFhO/M0E97g==",
+      "path": "microsoft.identitymodel.jsonwebtokens/8.0.1",
+      "hashPath": "microsoft.identitymodel.jsonwebtokens.8.0.1.nupkg.sha512"
+    },
+    "Microsoft.IdentityModel.Logging/8.0.1": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-UCPF2exZqBXe7v/6sGNiM6zCQOUXXQ9+v5VTb9gPB8ZSUPnX53BxlN78v2jsbIvK9Dq4GovQxo23x8JgWvm/Qg==",
+      "path": "microsoft.identitymodel.logging/8.0.1",
+      "hashPath": "microsoft.identitymodel.logging.8.0.1.nupkg.sha512"
+    },
+    "Microsoft.IdentityModel.Protocols/8.0.1": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-uA2vpKqU3I2mBBEaeJAWPTjT9v1TZrGWKdgK6G5qJd03CLx83kdiqO9cmiK8/n1erkHzFBwU/RphP83aAe3i3g==",
+      "path": "microsoft.identitymodel.protocols/8.0.1",
+      "hashPath": "microsoft.identitymodel.protocols.8.0.1.nupkg.sha512"
+    },
+    "Microsoft.IdentityModel.Protocols.OpenIdConnect/8.0.1": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-AQDbfpL+yzuuGhO/mQhKNsp44pm5Jv8/BI4KiFXR7beVGZoSH35zMV3PrmcfvSTsyI6qrcR898NzUauD6SRigg==",
+      "path": "microsoft.identitymodel.protocols.openidconnect/8.0.1",
+      "hashPath": "microsoft.identitymodel.protocols.openidconnect.8.0.1.nupkg.sha512"
+    },
+    "Microsoft.IdentityModel.Tokens/8.0.1": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-kDimB6Dkd3nkW2oZPDkMkVHfQt3IDqO5gL0oa8WVy3OP4uE8Ij+8TXnqg9TOd9ufjsY3IDiGz7pCUbnfL18tjg==",
+      "path": "microsoft.identitymodel.tokens/8.0.1",
+      "hashPath": "microsoft.identitymodel.tokens.8.0.1.nupkg.sha512"
+    },
+    "Microsoft.OpenApi/1.6.22": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-aBvunmrdu/x+4CaA/UP1Jx4xWGwk4kymhoIRnn2Vp+zi5/KOPQJ9EkSXHRUr01WcGKtYl3Au7XfkPJbU1G2sjQ==",
+      "path": "microsoft.openapi/1.6.22",
+      "hashPath": "microsoft.openapi.1.6.22.nupkg.sha512"
+    },
+    "Mono.TextTemplating/3.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-YqueG52R/Xej4VVbKuRIodjiAhV0HR/XVbLbNrJhCZnzjnSjgMJ/dCdV0akQQxavX6hp/LC6rqLGLcXeQYU7XA==",
+      "path": "mono.texttemplating/3.0.0",
+      "hashPath": "mono.texttemplating.3.0.0.nupkg.sha512"
+    },
+    "MySqlConnector/2.4.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-78M+gVOjbdZEDIyXQqcA7EYlCGS3tpbUELHvn6638A2w0pkPI625ixnzsa5staAd3N9/xFmPJtkKDYwsXpFi/w==",
+      "path": "mysqlconnector/2.4.0",
+      "hashPath": "mysqlconnector.2.4.0.nupkg.sha512"
+    },
+    "Pomelo.EntityFrameworkCore.MySql/9.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-cl7S4s6CbJno0LjNxrBHNc2xxmCliR5i40ATPZk/eTywVaAbHCbdc9vbGc3QThvwGjHqrDHT8vY9m1VF/47o0g==",
+      "path": "pomelo.entityframeworkcore.mysql/9.0.0",
+      "hashPath": "pomelo.entityframeworkcore.mysql.9.0.0.nupkg.sha512"
+    },
+    "Swashbuckle.AspNetCore/7.3.1": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-6u8w+UXp/sF89xQjfydWw6znQrUpbpFOmEIs8ODE+S0bV+mCQ9dNP4mk+HRsGHylpDaP5KSYSCEfFSgluLXHsA==",
+      "path": "swashbuckle.aspnetcore/7.3.1",
+      "hashPath": "swashbuckle.aspnetcore.7.3.1.nupkg.sha512"
+    },
+    "Swashbuckle.AspNetCore.Swagger/7.3.1": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-jQuJ8kVbq+YE8WsJE3RwWHlF1kasp0QkA9Gl6NeNLICrhcgN8IQIthMufYW6t/4hpcN5cBIdES5jCEV81WjHbA==",
+      "path": "swashbuckle.aspnetcore.swagger/7.3.1",
+      "hashPath": "swashbuckle.aspnetcore.swagger.7.3.1.nupkg.sha512"
+    },
+    "Swashbuckle.AspNetCore.SwaggerGen/7.3.1": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-xs7Pznb3SSjZy7HpThE0ILqECfQFsGDHOrRoIYD/j67ktdRR1juDG4AMyidXXCOipgzHanZoF+nFrc+Nmjqjyw==",
+      "path": "swashbuckle.aspnetcore.swaggergen/7.3.1",
+      "hashPath": "swashbuckle.aspnetcore.swaggergen.7.3.1.nupkg.sha512"
+    },
+    "Swashbuckle.AspNetCore.SwaggerUI/7.3.1": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-hs6C+lmNEzipOA1WPQpIaGvvoXjUbnoevbv6l7o9ZQE8SNF8ggjOmK6NB6cYdMcEvk0uBeKl4Qq/BnRt5MFVqg==",
+      "path": "swashbuckle.aspnetcore.swaggerui/7.3.1",
+      "hashPath": "swashbuckle.aspnetcore.swaggerui.7.3.1.nupkg.sha512"
+    },
+    "System.CodeDom/6.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-CPc6tWO1LAer3IzfZufDBRL+UZQcj5uS207NHALQzP84Vp/z6wF0Aa0YZImOQY8iStY0A2zI/e3ihKNPfUm8XA==",
+      "path": "system.codedom/6.0.0",
+      "hashPath": "system.codedom.6.0.0.nupkg.sha512"
+    },
+    "System.Composition/7.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-tRwgcAkDd85O8Aq6zHDANzQaq380cek9lbMg5Qma46u5BZXq/G+XvIYmu+UI+BIIZ9zssXLYrkTykEqxxvhcmg==",
+      "path": "system.composition/7.0.0",
+      "hashPath": "system.composition.7.0.0.nupkg.sha512"
+    },
+    "System.Composition.AttributedModel/7.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-2QzClqjElKxgI1jK1Jztnq44/8DmSuTSGGahXqQ4TdEV0h9s2KikQZIgcEqVzR7OuWDFPGLHIprBJGQEPr8fAQ==",
+      "path": "system.composition.attributedmodel/7.0.0",
+      "hashPath": "system.composition.attributedmodel.7.0.0.nupkg.sha512"
+    },
+    "System.Composition.Convention/7.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-IMhTlpCs4HmlD8B+J8/kWfwX7vrBBOs6xyjSTzBlYSs7W4OET4tlkR/Sg9NG8jkdJH9Mymq0qGdYS1VPqRTBnQ==",
+      "path": "system.composition.convention/7.0.0",
+      "hashPath": "system.composition.convention.7.0.0.nupkg.sha512"
+    },
+    "System.Composition.Hosting/7.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-eB6gwN9S+54jCTBJ5bpwMOVerKeUfGGTYCzz3QgDr1P55Gg/Wb27ShfPIhLMjmZ3MoAKu8uUSv6fcCdYJTN7Bg==",
+      "path": "system.composition.hosting/7.0.0",
+      "hashPath": "system.composition.hosting.7.0.0.nupkg.sha512"
+    },
+    "System.Composition.Runtime/7.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-aZJ1Zr5Txe925rbo4742XifEyW0MIni1eiUebmcrP3HwLXZ3IbXUj4MFMUH/RmnJOAQiS401leg/2Sz1MkApDw==",
+      "path": "system.composition.runtime/7.0.0",
+      "hashPath": "system.composition.runtime.7.0.0.nupkg.sha512"
+    },
+    "System.Composition.TypedParts/7.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-ZK0KNPfbtxVceTwh+oHNGUOYV2WNOHReX2AXipuvkURC7s/jPwoWfsu3SnDBDgofqbiWr96geofdQ2erm/KTHg==",
+      "path": "system.composition.typedparts/7.0.0",
+      "hashPath": "system.composition.typedparts.7.0.0.nupkg.sha512"
+    },
+    "System.IdentityModel.Tokens.Jwt/8.0.1": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-GJw3bYkWpOgvN3tJo5X4lYUeIFA2HD293FPUhKmp7qxS+g5ywAb34Dnd3cDAFLkcMohy5XTpoaZ4uAHuw0uSPQ==",
+      "path": "system.identitymodel.tokens.jwt/8.0.1",
+      "hashPath": "system.identitymodel.tokens.jwt.8.0.1.nupkg.sha512"
+    }
+  }
+}

Distribution.Tests/bin/Debug/net9.0/Distribution.runtimeconfig.json

@@ -0,0 +1,20 @@
+{
+  "runtimeOptions": {
+    "tfm": "net9.0",
+    "frameworks": [
+      {
+        "name": "Microsoft.NETCore.App",
+        "version": "9.0.0"
+      },
+      {
+        "name": "Microsoft.AspNetCore.App",
+        "version": "9.0.0"
+      }
+    ],
+    "configProperties": {
+      "System.GC.Server": true,
+      "System.Reflection.NullabilityInfoContext.IsSupported": true,
+      "System.Runtime.Serialization.EnableUnsafeBinaryFormatterSerialization": false
+    }
+  }
+}

Distribution.Tests/bin/Debug/net9.0/Distribution.staticwebassets.endpoints.json

@@ -0,0 +1 @@
+{"Version":1,"ManifestType":"Build","Endpoints":[]}

Distribution.Tests/bin/Debug/net9.0/appsettings.json

@@ -0,0 +1,18 @@
+{
+  "ConnectionStrings": {
+    "DefaultConnection": "Server=187.127.102.190;Port=3306;Database=distribution;User=kalana;Password=kalana@hexdive"
+  },
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft.AspNetCore": "Warning"
+    }
+  },
+  "AllowedHosts": "*",
+  "Jwt": {
+    "Key": "CHANGE_ME_dev_only_replace_with_a_long_random_secret_before_deploying",
+    "Issuer": "Distribution.Api",
+    "Audience": "Distribution.Api",
+    "ExpiryMinutes": 120
+  }
+}