ui and bug fixers 29/09

2026-09-29 14:49:11 +05:30
573 changed files with 302435 additions and 137266 deletions
@@ -45,24 +45,10 @@ jobs:
          find /home/erp/core/publish -type f -exec chmod 644 {} +
          chmod +x /home/erp/core/publish/ERPCore
      - name: Restart service
        # ConnectionStrings__DefaultConnection is supplied by the systemd unit on the host
        # (Environment= or EnvironmentFile=), deliberately not committed: appsettings.json ships
        # the key empty and appsettings.Production.json carries no ConnectionStrings section at
        # all. If the unit does not set it, startup throws before serving and the Verify step
        # below fails the job.
        run: systemctl restart erpcore.service
      - name: Verify
        run: |
-          # `is-active ... || echo` always exited 0, so a crashed service still reported success.
+          systemctl is-active erpcore.service && echo "✅ Service running" || echo "❌ Service failed"
          # Wait a few seconds first: a startup failure (bad or missing connection string) happens
          # during MigrateAsync, after systemctl restart has already returned.
          sleep 5
          if ! systemctl is-active --quiet erpcore.service; then
            echo "❌ erpcore.service is not running:"
            journalctl -u erpcore.service -n 50 --no-pager
            exit 1
          fi
          echo "✅ Service running"
  build-and-deploy-frontend:
    name: Build & Deploy Frontend
@@ -1,211 +0,0 @@
 using ERPCore.Domain.Enums;
 using ERPCore.Dtos.Accounts;
 using ERPCore.System.Errors;
 using ERPCore.Tests.TestSupport;
 using Microsoft.EntityFrameworkCore;
 using static ERPCore.Tests.TestSupport.BankDepositTestSupport;
 namespace ERPCore.Tests;
 /// <summary>Recording and cancelling bank deposits (docs/BANK_DEPOSIT_MODULE_PLAN.md §7.2, §11).</summary>
 public class BankDepositServiceTests
 {
    private static readonly DateOnly Today = Clock.Today;
    private static readonly DateOnly Start = Today.AddDays(-10);
    private static readonly DateOnly Day = Today.AddDays(-2);
    [Fact]
    public async Task Create_PostsBankDebitCashCredit_AndLowersCashInHand()
    {
        await using var db = CreateContext();
        db.SalesSlips.Add(CashSlip(Day, 1000));
        await db.SaveChangesAsync();
        var gl = new FakeGeneralLedger();
        var dto = await DepositService(db, Start, gl).CreateAsync(Request(600, depositDate: Day.AddDays(1)));
        Assert.Equal(BankDepositStatus.Posted, dto.Status);
        Assert.Equal(("BOC Current", "Bank of Ceylon", "0001234567"), (dto.ToBankAccountName, dto.ToBankName, dto.ToAccountNumber));
        Assert.Equal("JE-1", dto.GlJournalNo);
        var entry = Assert.Single(gl.Posted);
        Assert.Equal(Day.AddDays(1), entry.EntryDate);
        Assert.Equal("BANK_DEPOSIT", entry.SourceModule);
        Assert.Collection(entry.Lines,
            l => Assert.Equal(("1010-01", 600m, 0m), (l.AccountCode, l.DebitAmount, l.CreditAmount)),
            l => Assert.Equal(("1000-01", 0m, 600m), (l.AccountCode, l.DebitAmount, l.CreditAmount)));
        var position = await CashService(db, Start).GetPositionAsync(Day, Branch1);
        Assert.Equal((600m, 400m), (position.Position.Deposited, position.Position.Closing));
    }
    [Fact]
    public async Task Create_MoreThanCashInHand_IsRejected()
    {
        await using var db = CreateContext();
        db.SalesSlips.Add(CashSlip(Day, 1000, card: 5000));
        await db.SaveChangesAsync();
        var gl = new FakeGeneralLedger();
        var ex = await Assert.ThrowsAsync<DomainException>(() => DepositService(db, Start, gl).CreateAsync(Request(1000.01m)));
        Assert.Equal(ErrorCodes.BankDepositExceedsCashInHand, ex.Code);
        Assert.Empty(gl.Posted);
    }
    [Fact]
    public async Task Create_BackDatedDepositThatOverdrawsALaterDay_IsRejected()
    {
        await using var db = CreateContext();
        db.SalesSlips.Add(CashSlip(Day, 1000));
        db.BankDeposits.Add(Deposit(Day.AddDays(1), 900));     // the next day already banked most of it
        await db.SaveChangesAsync();
        var ex = await Assert.ThrowsAsync<DomainException>(() =>
            DepositService(db, Start, new FakeGeneralLedger()).CreateAsync(Request(500)));
        Assert.Equal(ErrorCodes.BankDepositExceedsCashInHand, ex.Code);
        Assert.Contains("100.00", ex.Message);
    }
    [Fact]
    public async Task Cancel_ReversesGl_AndPutsTheCashBack()
    {
        await using var db = CreateContext();
        db.SalesSlips.Add(CashSlip(Day, 1000));
        await db.SaveChangesAsync();
        var gl = new FakeGeneralLedger();
        var service = DepositService(db, Start, gl);
        var created = await service.CreateAsync(Request(1000));
        var cancelled = await service.CancelAsync(created.BankDepositId, new CancelBankDepositRequest { Reason = " wrong bank " });
        Assert.Equal(BankDepositStatus.Cancelled, cancelled.Status);
        Assert.Equal("wrong bank", cancelled.CancelReason);
        Assert.Equal("JE-2", cancelled.GlReversalJournalNo);
        Assert.Collection(gl.Posted[1].Lines,
            l => Assert.Equal(("1000-01", 1000m, 0m), (l.AccountCode, l.DebitAmount, l.CreditAmount)),
            l => Assert.Equal(("1010-01", 0m, 1000m), (l.AccountCode, l.DebitAmount, l.CreditAmount)));
        Assert.Equal(1000m, (await CashService(db, Start).GetPositionAsync(Day, Branch1)).Position.Closing);
        var again = await Assert.ThrowsAsync<DomainException>(() =>
            service.CancelAsync(created.BankDepositId, new CancelBankDepositRequest { Reason = "again" }));
        Assert.Equal(ErrorCodes.BankDepositNotCancellable, again.Code);
    }
    [Theory]
    [InlineData(FakeGeneralLedger.BankAccountId, FakeGeneralLedger.BankAccountId, ErrorCodes.BankDepositCashAccountInvalid)]
    [InlineData(FakeGeneralLedger.CashAccountId, FakeGeneralLedger.CashAccountId, ErrorCodes.BankDepositBankAccountInvalid)]
    [InlineData(99L, FakeGeneralLedger.BankAccountId, ErrorCodes.BankDepositCashAccountInvalid)]
    public async Task Create_WrongAccountTypes_AreRejected(long from, long to, string code)
    {
        await using var db = CreateContext();
        db.SalesSlips.Add(CashSlip(Day, 1000));
        await db.SaveChangesAsync();
        var request = Request(100);
        request.FromGlCashAccountId = from;
        request.ToGlBankAccountId = to;
        var ex = await Assert.ThrowsAsync<DomainException>(() => DepositService(db, Start, new FakeGeneralLedger()).CreateAsync(request));
        Assert.Equal(code, ex.Code);
    }
    [Fact]
    public async Task Create_CashAndBankAccountsSharingAnId_AreToldApartByType()
    {
        await using var db = CreateContext();
        db.SalesSlips.Add(CashSlip(Day, 1000));
        await db.SaveChangesAsync();
        // GL numbers cash and bank accounts in separate tables, so both can be account 1.
        var gl = new FakeGeneralLedger
        {
            Accounts =
            [
                new("Cash", 1, "main", null, "Cash in Transit", "CASH-000001", 22, "1400-01-01", "LKR"),
                new("Bank", 1, "Main - 01", "Commercial Bank", null, "2032434543", 2, "1000-01", "LKR")
            ]
        };
        var request = Request(400);
        request.FromGlCashAccountId = 1;
        request.ToGlBankAccountId = 1;
        var dto = await DepositService(db, Start, gl).CreateAsync(request);
        Assert.Equal(("main", "Main - 01"), (dto.FromCashAccountName, dto.ToBankAccountName));
        Assert.Collection(Assert.Single(gl.Posted).Lines,
            l => Assert.Equal(("1000-01", 400m), (l.AccountCode, l.DebitAmount)),
            l => Assert.Equal(("1400-01-01", 400m), (l.AccountCode, l.CreditAmount)));
    }
    [Fact]
    public async Task Create_CannotUseAnotherBranchsCash()
    {
        await using var db = CreateContext();
        db.SalesSlips.Add(CashSlip(Day, 1000, warehouseId: Warehouse2));
        await db.SaveChangesAsync();
        var ex = await Assert.ThrowsAsync<DomainException>(() =>
            DepositService(db, Start, new FakeGeneralLedger()).CreateAsync(Request(100, branchId: Branch1)));
        Assert.Equal(ErrorCodes.BankDepositExceedsCashInHand, ex.Code);
    }
    [Theory]
    [InlineData(-11, null)]   // before tracking starts
    [InlineData(1, null)]     // business date in the future
    [InlineData(-2, -3)]      // deposited before the business day
    [InlineData(-2, 2)]       // deposit date beyond tomorrow
    public async Task Create_InvalidDates_AreRejected(int businessOffset, int? depositOffset)
    {
        await using var db = CreateContext();
        var request = Request(100);
        request.BusinessDate = Today.AddDays(businessOffset);
        request.DepositDate = depositOffset is { } d ? Today.AddDays(d) : null;
        var ex = await Assert.ThrowsAsync<DomainException>(() => DepositService(db, Start, new FakeGeneralLedger()).CreateAsync(request));
        Assert.Equal(ErrorCodes.BankDepositDateInvalid, ex.Code);
    }
    [Fact]
    public async Task Create_GlRejection_LeavesNoDeposit()
    {
        await using var db = CreateContext();
        db.SalesSlips.Add(CashSlip(Day, 1000));
        await db.SaveChangesAsync();
        await Assert.ThrowsAsync<DomainException>(() =>
            DepositService(db, Start, new FakeGeneralLedger { Reject = true }).CreateAsync(Request(500)));
        Assert.Equal(0, await db.BankDeposits.CountAsync());
    }
    [Fact]
    public async Task List_FiltersAndTotalsEveryMatchingRow()
    {
        await using var db = CreateContext();
        db.BankDeposits.AddRange(
            Deposit(Day, 100), Deposit(Day, 200), Deposit(Day.AddDays(-1), 400),
            Deposit(Day, 800, branchId: Branch2), Deposit(Day, 1600, status: BankDepositStatus.Cancelled));
        await db.SaveChangesAsync();
        var result = await DepositService(db, Start, new FakeGeneralLedger()).ListAsync(
            new() { PageSize = 1 }, new BankDepositListFilter(Day, Day, Branch1, null, BankDepositStatus.Posted));
        Assert.Single(result.Items);
        Assert.Equal(2, result.Pagination.TotalItems);
        Assert.Equal(300m, result.TotalAmount);
    }
    private static CreateBankDepositRequest Request(decimal amount, int branchId = Branch1, DateOnly? depositDate = null) => new()
    {
        BranchId = branchId,
        BusinessDate = Day,
        DepositDate = depositDate,
        Amount = amount,
        FromGlCashAccountId = FakeGeneralLedger.CashAccountId,
        ToGlBankAccountId = FakeGeneralLedger.BankAccountId,
        DepositSlipNo = "SLIP-1"
    };
 }
@@ -1,134 +0,0 @@
 using ERPCore.Domain.Entities;
 using ERPCore.Domain.Enums;
 using static ERPCore.Tests.TestSupport.BankDepositTestSupport;
 namespace ERPCore.Tests;
 /// <summary>Till cash in hand (docs/BANK_DEPOSIT_MODULE_PLAN.md §2, §11).</summary>
 public class CashInHandServiceTests
 {
    private static readonly DateOnly Today = Clock.Today;
    private static readonly DateOnly Start = Today.AddDays(-10);
    [Fact]
    public async Task OnlyCashIsCounted()
    {
        await using var db = CreateContext();
        var day = Today.AddDays(-2);
        db.SalesSlips.AddRange(
            CashSlip(day, cash: 300, card: 200),   // only the 300 is till cash
            CashSlip(day, cash: 0, card: 900));
        db.SalesInvoices.Add(new SalesInvoice
        {
            SalesInvoiceId = 1, InvoiceNo = "INV-1", InvoiceDate = At(day.AddDays(-5)), Status = SalesInvoiceStatus.Posted, BranchId = Branch1
        });
        db.SalesInvoicePayments.AddRange(
            new SalesInvoicePayment { SalesInvoicePaymentId = 1, SalesInvoiceId = 1, PaymentDate = At(day), PaymentMethod = SalesPaymentMethod.Cash, Amount = 150 },
            new SalesInvoicePayment { SalesInvoicePaymentId = 2, SalesInvoiceId = 1, PaymentDate = At(day), PaymentMethod = SalesPaymentMethod.Card, Amount = 500 },
            new SalesInvoicePayment { SalesInvoicePaymentId = 3, SalesInvoiceId = 1, PaymentDate = At(day), PaymentMethod = SalesPaymentMethod.Cheque, Amount = 70 });
        db.Expenses.Add(new Expense { ExpenseId = 1, DocNo = "EXP-1", BranchId = Branch1, ExpenseDate = day, Amount = 100, Status = ExpenseStatus.Posted });
        db.ExpensePayments.AddRange(
            new ExpensePayment { ExpensePaymentId = 1, ExpenseId = 1, PaymentDate = At(day), PaymentMethod = ExpensePaymentMethod.Cash, Amount = 40 },
            new ExpensePayment { ExpensePaymentId = 2, ExpenseId = 1, PaymentDate = At(day), PaymentMethod = ExpensePaymentMethod.BankTransfer, Amount = 60 });
        await db.SaveChangesAsync();
        var p = (await CashService(db, Start).GetPositionAsync(day, Branch1)).Position;
        Assert.Equal(450m, p.CashIn);
        Assert.Equal(40m, p.CashOut);
        Assert.Equal(410m, p.NetCash);
        Assert.Equal(410m, p.Closing);
    }
    [Fact]
    public async Task UndepositedCash_CarriesToTheNextDay_AndDepositsReduceIt()
    {
        await using var db = CreateContext();
        var d1 = Today.AddDays(-3);
        var d2 = Today.AddDays(-2);
        db.SalesSlips.AddRange(CashSlip(d1, 1000), CashSlip(d2, 500));
        db.BankDeposits.AddRange(
            Deposit(d1, 600),
            Deposit(d1, 999, status: BankDepositStatus.Cancelled));   // ignored
        await db.SaveChangesAsync();
        var days = (await CashService(db, Start).GetDailyAsync(d1, d2, Branch1)).Days;
        Assert.Equal((0m, 1000m, 600m, 400m), (days[0].Opening, days[0].NetCash, days[0].Deposited, days[0].Closing));
        Assert.Equal((400m, 500m, 0m, 900m), (days[1].Opening, days[1].NetCash, days[1].Deposited, days[1].Closing));
    }
    [Fact]
    public async Task Opening_IsCarriedInFromBeforeTheWindow()
    {
        await using var db = CreateContext();
        db.SalesSlips.AddRange(CashSlip(Today.AddDays(-6), 700), CashSlip(Today.AddDays(-5), 300));
        db.BankDeposits.Add(Deposit(Today.AddDays(-5), 200));
        await db.SaveChangesAsync();
        var day = (await CashService(db, Start).GetPositionAsync(Today.AddDays(-1), Branch1)).Position;
        Assert.Equal(800m, day.Opening);
        Assert.Equal(800m, day.Closing);
    }
    [Fact]
    public async Task CashBeforeTheTrackingStart_IsNotCarried()
    {
        await using var db = CreateContext();
        db.SalesSlips.AddRange(CashSlip(Start.AddDays(-1), 5000), CashSlip(Start, 100));
        await db.SaveChangesAsync();
        var days = (await CashService(db, Start).GetDailyAsync(Start.AddDays(-1), Start, Branch1)).Days;
        Assert.Equal(5000m, days[0].NetCash);      // still reported for the day itself
        Assert.Equal(0m, days[1].Opening);         // but not carried into tracking
        Assert.Equal(100m, days[1].Closing);
    }
    [Fact]
    public async Task Available_IsTheLowestClosingFromThatDayToToday()
    {
        await using var db = CreateContext();
        var d1 = Today.AddDays(-2);
        db.SalesSlips.Add(CashSlip(d1, 1000));
        db.BankDeposits.Add(Deposit(Today.AddDays(-1), 800));      // already took most of it the next day
        await db.SaveChangesAsync();
        var position = await CashService(db, Start).GetPositionAsync(d1, Branch1);
        Assert.Equal(1000m, position.Position.Closing);
        Assert.Equal(200m, position.AvailableToDeposit);
    }
    [Fact]
    public async Task Branches_AreKeptApart()
    {
        await using var db = CreateContext();
        var day = Today.AddDays(-1);
        db.SalesSlips.AddRange(CashSlip(day, 100, warehouseId: Warehouse1), CashSlip(day, 900, warehouseId: Warehouse2));
        await db.SaveChangesAsync();
        var service = CashService(db, Start);
        Assert.Equal(100m, (await service.GetPositionAsync(day, Branch1)).Position.Closing);
        Assert.Equal(900m, (await service.GetPositionAsync(day, Branch2)).Position.Closing);
        Assert.Equal(1000m, (await service.GetPositionAsync(day, null)).Position.Closing);
    }
    [Fact]
    public async Task LateEveningSale_CountsOnTheLocalDay()
    {
        await using var db = CreateContext();
        var day = Today.AddDays(-1);
        var slip = CashSlip(day, 250);
        slip.SlipDate = Clock.ToUtc(day.AddDays(1)).AddMinutes(-30);    // 23:30 local
        db.SalesSlips.Add(slip);
        await db.SaveChangesAsync();
        var days = (await CashService(db, Start).GetDailyAsync(day, day.AddDays(1), Branch1)).Days;
        Assert.Equal(250m, days[0].CashIn);
        Assert.Equal(0m, days[1].CashIn);
    }
 }
@@ -1,257 +0,0 @@
 using ERPCore.Domain;
 using ERPCore.Domain.Entities;
 using ERPCore.Domain.Enums;
 using ERPCore.Infra.Auth;
 using ERPCore.Infra.Persistence;
 using ERPCore.Repositories;
 using ERPCore.Services;
 using ERPCore.System.Errors;
 using ERPCore.Tests.TestSupport;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Storage;
 using Microsoft.Extensions.Configuration;
 namespace ERPCore.Tests;
 /// <summary>Aggregates of the Day-End Sales Report (docs/DAY_END_SALES_REPORT_PLAN.md §7).</summary>
 public class DayEndReportServiceTests
 {
    private static readonly InMemoryDatabaseRoot Root = new();
    // Asia/Colombo is UTC+05:30 all year (no DST), so local midnight is 18:30 UTC the day before.
    private static readonly DateOnly Day = new(2026, 10, 8);
    private static DateTime UtcAt(int hour, int minute = 0) => new(2026, 10, 8, hour, minute, 0, DateTimeKind.Utc);
    [Fact]
    public async Task Day_MixOfSlipsBundlesAndInvoices_TotalsAndSplitsByMethod()
    {
        await using var db = CreateContext();
        db.SalesSlips.AddRange(
            Slip(1, UtcAt(5), total: 1000, paid: 600, cash: 400, card: 200),   // partial, mixed
            Slip(2, UtcAt(6), total: 200, paid: 200, cash: 200, card: 0),      // all cash
            Slip(3, UtcAt(7), total: 999, paid: 999, cash: 999, card: 0, status: SalesSlipStatus.Draft));
        db.BundleSales.Add(new BundleSale { BundleSaleId = 1, BundleDate = UtcAt(8), Status = BundleSaleStatus.Posted, GrandTotal = 500, CashAmount = 0, CardAmount = 500 });
        db.SalesInvoices.Add(Invoice(1, UtcAt(9), netPayable: 2000, paid: 1500));
        db.SalesInvoicePayments.AddRange(
            Payment(1, invoiceId: 1, UtcAt(9), SalesPaymentMethod.Cash, 500),
            Payment(2, invoiceId: 1, UtcAt(10), SalesPaymentMethod.Card, 1000));
        SeedExpenseSetup(db);
        db.Expenses.AddRange(
            Expense(1, Day, 300, ExpenseStatus.Posted),
            Expense(2, Day, 700, ExpenseStatus.Cancelled),
            Expense(3, Day.AddDays(1), 50, ExpenseStatus.Posted));
        await db.SaveChangesAsync();
        var report = await CreateService(db).GetDayAsync(Day, null);
        var s = report.Summary;
        Assert.Equal(3700m, s.TotalSales);
        Assert.Equal(2800m, s.PaidAmount);
        Assert.Equal(900m, s.DueAmount);
        Assert.Equal(1100m, s.PaidByCash);
        Assert.Equal(1700m, s.PaidByCard);
        Assert.Equal(0m, s.PaidByOther);
        Assert.Equal(4, s.SalesCount);
        Assert.Equal(1, s.CashSalesCount);
        Assert.Equal(1, s.CardSalesCount);
        Assert.Equal(2, s.MixedSalesCount);
        Assert.Equal(0, s.UnpaidSalesCount);
        Assert.Equal(300m, s.ExpenseTotal);
        Assert.Equal(3400m, s.Income);
        Assert.Single(report.Expenses);
        Assert.Equal("Electricity", report.Expenses[0].TitleName);
    }
    [Fact]
    public async Task Day_SaleLateInTheLocalEvening_CountsOnTheLocalDay()
    {
        await using var db = CreateContext();
        // 19:00 UTC on Oct 7 is 00:30 on Oct 8 in Colombo; 18:00 UTC on Oct 8 is 23:30 on Oct 8.
        db.SalesSlips.AddRange(
            Slip(1, new DateTime(2026, 10, 7, 19, 0, 0, DateTimeKind.Utc), total: 100, paid: 100, cash: 100, card: 0),
            Slip(2, new DateTime(2026, 10, 8, 18, 0, 0, DateTimeKind.Utc), total: 40, paid: 40, cash: 40, card: 0),
            Slip(3, new DateTime(2026, 10, 8, 19, 0, 0, DateTimeKind.Utc), total: 7, paid: 7, cash: 7, card: 0));
        await db.SaveChangesAsync();
        var report = await CreateService(db).GetDailyAsync(Day.AddDays(-1), Day.AddDays(1), null);
        Assert.Equal([0m, 140m, 7m], report.Days.Select(d => d.TotalSales));
        Assert.Equal(147m, report.Totals.TotalSales);
    }
    [Fact]
    public async Task Day_PaymentOnAnEarlierInvoice_IsACollectionAndCountsInNetCash()
    {
        await using var db = CreateContext();
        db.SalesInvoices.Add(Invoice(1, UtcAt(5).AddDays(-3), netPayable: 800, paid: 250));
        db.SalesInvoicePayments.Add(Payment(1, invoiceId: 1, UtcAt(6), SalesPaymentMethod.Cash, 250));
        db.SalesSlips.Add(Slip(1, UtcAt(7), total: 60, paid: 60, cash: 60, card: 0));
        SeedExpenseSetup(db);
        db.Expenses.Add(Expense(1, Day, 30, ExpenseStatus.Posted));
        db.ExpensePayments.Add(new ExpensePayment { ExpensePaymentId = 1, ExpenseId = 1, Amount = 30, PaymentDate = UtcAt(8), PaymentMethod = ExpensePaymentMethod.Cash });
        await db.SaveChangesAsync();
        var s = (await CreateService(db).GetDayAsync(Day, null)).Summary;
        Assert.Equal(60m, s.TotalSales);
        Assert.Equal(60m, s.PaidAmount);
        Assert.Equal(250m, s.EarlierInvoiceCollections);
        Assert.Equal(60m + 250m - 30m, s.NetCash);
    }
    [Fact]
    public async Task Day_ShowsBankDepositsAndTheCashLeftInHand()
    {
        await using var db = CreateContext();
        db.SalesSlips.AddRange(
            Slip(1, UtcAt(5).AddDays(-1), total: 300, paid: 300, cash: 300, card: 0),   // yesterday, never banked
            Slip(2, UtcAt(6), total: 1000, paid: 1000, cash: 1000, card: 0));
        db.BankDeposits.AddRange(
            BankDeposit(1, Day, 800, BankDepositStatus.Posted),
            BankDeposit(2, Day, 5000, BankDepositStatus.Cancelled));
        await db.SaveChangesAsync();
        var report = await CreateService(db).GetDayAsync(Day, null);
        var s = report.Summary;
        Assert.Equal((300m, 1000m, 800m, 500m), (s.OpeningCashInHand, s.NetCash, s.CashDeposited, s.ClosingCashInHand));
        var deposit = Assert.Single(report.Deposits);
        Assert.Equal(("BD-1", "BOC Current", 800m), (deposit.DocNo, deposit.BankAccountName, deposit.Amount));
        var range = await CreateService(db).GetDailyAsync(Day.AddDays(-1), Day, null);
        Assert.Equal((0m, 800m, 500m), (range.Totals.OpeningCashInHand, range.Totals.CashDeposited, range.Totals.ClosingCashInHand));
    }
    [Fact]
    public async Task Day_Profit_IsSalesLessStockCostLessExpenses_AndCanBeALoss()
    {
        await using var db = CreateContext();
        db.SalesInvoices.Add(Invoice(1, UtcAt(5), netPayable: 1000, paid: 1000));
        db.SalesInvoicePayments.Add(Payment(1, invoiceId: 1, UtcAt(5), SalesPaymentMethod.Card, 1000));
        db.SalesSlips.Add(Slip(1, UtcAt(6), total: 200, paid: 0, cash: 0, card: 0));
        db.StockLedger.AddRange(
            Ledger(1, DocumentTypes.SalesInvoice, 1, Direction.Out, 600),
            Ledger(2, DocumentTypes.SalesInvoice, 1, Direction.Out, 100),
            Ledger(3, DocumentTypes.SalesSlip, 1, Direction.Out, 150),
            Ledger(4, DocumentTypes.SalesInvoice, 1, Direction.In, 999));   // not a sale's cost
        SeedExpenseSetup(db);
        db.Expenses.Add(Expense(1, Day, 900, ExpenseStatus.Posted));
        await db.SaveChangesAsync();
        var report = await CreateService(db).GetDayAsync(Day, null);
        var s = report.Summary;
        Assert.Equal(850m, s.CostOfGoodsSold);
        Assert.Equal(350m, s.GrossProfit);
        Assert.Equal(-550m, s.NetProfit);
        Assert.Equal(2, report.Sales.Count);
        var invoice = report.Sales.Single(x => x.DocType == "Invoice");
        Assert.Equal(("Card", 700m, 300m), (invoice.PaidBy, invoice.Cost, invoice.GrossProfit));
        Assert.Equal("Unpaid", report.Sales.Single(x => x.DocType == "Slip").PaidBy);
    }
    [Fact]
    public async Task Day_UnpaidInvoice_CountsAsUnpaidAndDue()
    {
        await using var db = CreateContext();
        db.SalesInvoices.Add(Invoice(1, UtcAt(5), netPayable: 450, paid: 0));
        await db.SaveChangesAsync();
        var s = (await CreateService(db).GetDayAsync(Day, null)).Summary;
        Assert.Equal(1, s.UnpaidSalesCount);
        Assert.Equal(450m, s.DueAmount);
    }
    [Fact]
    public async Task Daily_FillsQuietDaysWithZeros()
    {
        await using var db = CreateContext();
        var report = await CreateService(db).GetDailyAsync(Day, Day.AddDays(4), null);
        Assert.Equal(5, report.Days.Count);
        Assert.All(report.Days, d => Assert.Equal(0m, d.Income));
        Assert.Equal(Day.AddDays(4), report.Days[^1].Date);
    }
    [Theory]
    [InlineData(1, 0)]   // to before from
    [InlineData(0, 92)]  // 93 days
    public async Task Daily_InvalidRange_IsRejected(int fromOffset, int toOffset)
    {
        await using var db = CreateContext();
        var ex = await Assert.ThrowsAsync<DomainException>(() =>
            CreateService(db).GetDailyAsync(Day.AddDays(fromOffset), Day.AddDays(toOffset), null));
        Assert.Equal(ErrorCodes.DayEndReportRangeInvalid, ex.Code);
    }
    // --- helpers ------------------------------------------------------------------------------
    private static SalesSlip Slip(int id, DateTime at, decimal total, decimal paid, decimal cash, decimal card,
        SalesSlipStatus status = SalesSlipStatus.Posted) => new()
    {
        SalesSlipId = id, SlipNo = $"SL-{id}", SlipDate = at, Status = status,
        GrandTotal = total, PaidAmount = paid, BalanceAmount = total - paid, CashAmount = cash, CardAmount = card
    };
    private static SalesInvoice Invoice(int id, DateTime at, decimal netPayable, decimal paid) => new()
    {
        SalesInvoiceId = id, InvoiceNo = $"INV-{id}", InvoiceDate = at, Status = SalesInvoiceStatus.Posted,
        GrandTotal = netPayable, NetPayable = netPayable, PaidAmount = paid, BalanceAmount = netPayable - paid
    };
    private static SalesInvoicePayment Payment(int id, int invoiceId, DateTime at, SalesPaymentMethod method, decimal amount) => new()
    {
        SalesInvoicePaymentId = id, SalesInvoiceId = invoiceId, PaymentDate = at, PaymentMethod = method, Amount = amount
    };
    private static StockLedger Ledger(int id, string docType, int docId, Direction direction, decimal value) => new()
    {
        LedgerId = id, SourceDocType = docType, SourceDocId = docId, Direction = direction, Value = value, QtyBase = 1, ItemId = 1, WarehouseId = 1
    };
    private static Expense Expense(int id, DateOnly date, decimal amount, ExpenseStatus status) => new()
    {
        ExpenseId = id, DocNo = $"EXP-{id}", ExpenseDate = date, Amount = amount, Status = status,
        ExpenseCategoryId = 1, ExpenseTitleId = 1
    };
    private static BankDeposit BankDeposit(int id, DateOnly businessDate, decimal amount, BankDepositStatus status) => new()
    {
        BankDepositId = id, DocNo = $"BD-{id}", BranchId = 1, BusinessDate = businessDate, DepositDate = businessDate, Amount = amount,
        Status = status, FromCashAccountCode = "1000-01", FromCashAccountName = "Main Till",
        ToBankAccountCode = "1010-01", ToBankAccountName = "BOC Current"
    };
    private static void SeedExpenseSetup(ErpDbContext db)
    {
        db.ExpenseCategories.Add(new ExpenseCategory { ExpenseCategoryId = 1, Code = "UTILITY", Name = "Utility" });
        db.ExpenseTitles.Add(new ExpenseTitle { ExpenseTitleId = 1, ExpenseCategoryId = 1, Name = "Electricity", GlExpenseAccountCode = "5200-01" });
    }
    private static DayEndReportService CreateService(ErpDbContext db)
    {
        var config = new ConfigurationBuilder()
            .AddInMemoryCollection(new Dictionary<string, string?> { ["DayEndReport:TimeZone"] = "Asia/Colombo" })
            .Build();
        var clock = new BusinessDayClock(config);
        var branch = new CurrentBranchContext(new TestCurrentUser());
        var cash = new CashInHandService(
            new Repository<SalesSlip>(db), new Repository<BundleSale>(db), new Repository<SalesInvoicePayment>(db),
            new Repository<ExpensePayment>(db), new Repository<BankDeposit>(db), branch, clock, config);
        return new DayEndReportService(
            new Repository<SalesSlip>(db), new Repository<BundleSale>(db), new Repository<SalesInvoice>(db),
            new Repository<SalesInvoicePayment>(db), new Repository<StockLedger>(db),
            new Repository<Expense>(db), new Repository<BankDeposit>(db), cash, branch, clock);
    }
    private static ErpDbContext CreateContext()
    {
        var options = new DbContextOptionsBuilder<ErpDbContext>()
            .UseInMemoryDatabase(Guid.NewGuid().ToString("N"), Root)
            .Options;
        var currentUser = new TestCurrentUser();
        return new ErpDbContext(options, currentUser, new CurrentBranchContext(currentUser));
    }
 }
@@ -1,388 +0,0 @@
 using ERPCore.Domain;
 using ERPCore.Domain.Entities;
 using ERPCore.Domain.Enums;
 using ERPCore.Dtos.Approvals;
 using ERPCore.Dtos.Notifications;
 using ERPCore.Dtos.Products;
 using ERPCore.Dtos.Stock;
 using ERPCore.Infra.Auth;
 using ERPCore.Infra.Persistence;
 using ERPCore.Repositories;
 using ERPCore.Services;
 using ERPCore.Services.Interfaces;
 using ERPCore.Services.Stock;
 using ERPCore.System.Errors;
 using ERPCore.Tests.TestSupport;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Storage;
 using Microsoft.Extensions.Configuration;
 namespace ERPCore.Tests;
 /// <summary>Dual approval of stock and price adjustments (docs/DUAL_APPROVAL_PLAN.md §13).</summary>
 public class DualApprovalTests
 {
    private static readonly InMemoryDatabaseRoot Root = new();
    // Requester, two approvers, and a clerk who can approve but isn't a manager.
    private const int Requester = 10, ApproverA = 11, ApproverB = 12, Clerk = 13;
    private const int ApproverRoleId = 2, ClerkRoleId = 3;
    private const int ItemId = 1, WarehouseId = 1, ReasonId = 1;
    // --- Stock adjustments ------------------------------------------------------------------
    [Fact]
    public async Task StockAdjustment_IsARequest_NothingMovesUntilApproved()
    {
        var h = await Harness.CreateAsync();
        var dto = await h.Stock.CreateAsync(Request(-3));
        Assert.Equal(AdjustmentStatus.PendingApproval, dto.Status);
        Assert.Equal(2, dto.RequiredApprovals);
        Assert.Equal(1, dto.PendingLevel);
        Assert.Empty(h.Mutator.Calls);
        Assert.Empty(h.Gl.Posted);
        var pending = Assert.Single(h.Notifications.Targeted, n => n.ModuleKey == "approval.pending");
        Assert.Equal([ApproverA, ApproverB, Clerk], pending.UserIds.Order());   // never the requester
    }
    [Fact]
    public async Task StockAdjustment_TwoDifferentApprovers_ThenItPosts()
    {
        var h = await Harness.CreateAsync();
        var id = (await h.Stock.CreateAsync(Request(-3))).AdjustmentId;
        h.User.Be(Requester);
        var own = await Assert.ThrowsAsync<DomainException>(() => h.Stock.ApproveAsync(id, null));
        Assert.Equal(ErrorCodes.ApprovalForbidden, own.Code);
        h.User.Be(ApproverA);
        var first = await h.Stock.ApproveAsync(id, "counted twice");
        Assert.Equal(AdjustmentStatus.PendingSecondApproval, first.Status);
        Assert.Empty(h.Mutator.Calls);
        var twice = await Assert.ThrowsAsync<DomainException>(() => h.Stock.ApproveAsync(id, null));
        Assert.Equal(ErrorCodes.ApprovalSamePerson, twice.Code);
        h.User.Be(ApproverB);
        var posted = await h.Stock.ApproveAsync(id, null);
        Assert.Equal(AdjustmentStatus.Posted, posted.Status);
        Assert.Equal((ApproverA, ApproverB), (posted.ApprovedLevel1By, posted.ApprovedLevel2By));
        var call = Assert.Single(h.Mutator.Calls);
        Assert.Equal(-3m, Assert.Single(call).QtyDelta);
        Assert.Single(h.Gl.Posted);
        Assert.NotNull(posted.PostedAt);
        Assert.Equal([1, 2], posted.ApprovalHistory!.Select(s => s.Level));
        Assert.Contains(h.Notifications.Targeted, n => n.ModuleKey == "approval.approved" && n.UserIds.SequenceEqual([Requester]));
    }
    [Fact]
    public async Task StockAdjustment_Rejected_NeedsAReason_AndNeverPosts()
    {
        var h = await Harness.CreateAsync();
        var id = (await h.Stock.CreateAsync(Request(5))).AdjustmentId;
        h.User.Be(ApproverA);
        var noReason = await Assert.ThrowsAsync<DomainException>(() => h.Stock.RejectAsync(id, " "));
        Assert.Equal(ErrorCodes.ApprovalReasonRequired, noReason.Code);
        var rejected = await h.Stock.RejectAsync(id, "wrong warehouse");
        Assert.Equal((AdjustmentStatus.Rejected, "wrong warehouse"), (rejected.Status, rejected.RejectReason));
        h.User.Be(ApproverB);
        var late = await Assert.ThrowsAsync<DomainException>(() => h.Stock.ApproveAsync(id, null));
        Assert.Equal(ErrorCodes.ApprovalNotPending, late.Code);
        Assert.Empty(h.Mutator.Calls);
        Assert.Contains(h.Notifications.Targeted, n => n.ModuleKey == "approval.rejected");
    }
    [Fact]
    public async Task StockAdjustment_ApprovalsOff_PostsOnCreate()
    {
        var h = await Harness.CreateAsync(stockLevels: 0);
        var dto = await h.Stock.CreateAsync(Request(2));
        Assert.Equal((AdjustmentStatus.Posted, 0), (dto.Status, dto.RequiredApprovals));
        Assert.Single(h.Mutator.Calls);
    }
    [Fact]
    public async Task StockAdjustment_BelowTheValueThreshold_NeedsOneApproval()
    {
        // 3 units at 10.00 each = 30.00, below the 1,000 threshold.
        var h = await Harness.CreateAsync(stockThreshold: 1000);
        var id = (await h.Stock.CreateAsync(Request(-3))).AdjustmentId;
        h.User.Be(ApproverA);
        var posted = await h.Stock.ApproveAsync(id, null);
        Assert.Equal((AdjustmentStatus.Posted, 1), (posted.Status, posted.RequiredApprovals));
        Assert.Single(h.Mutator.Calls);
    }
    [Fact]
    public async Task StockAdjustment_OnlyTheRequesterCanWithdraw()
    {
        var h = await Harness.CreateAsync();
        var id = (await h.Stock.CreateAsync(Request(-1))).AdjustmentId;
        h.User.Be(ApproverA);
        var other = await Assert.ThrowsAsync<DomainException>(() => h.Stock.CancelAsync(id));
        Assert.Equal(ErrorCodes.ApprovalForbidden, other.Code);
        h.User.Be(Requester);
        Assert.Equal(AdjustmentStatus.Cancelled, (await h.Stock.CancelAsync(id)).Status);
    }
    [Fact]
    public async Task SecondApproval_CanBeLimitedToRoles()
    {
        var h = await Harness.CreateAsync(level2Roles: "Approver");
        var id = (await h.Stock.CreateAsync(Request(-1))).AdjustmentId;
        h.User.Be(ApproverA);
        await h.Stock.ApproveAsync(id, null);
        h.User.Be(Clerk);
        var clerk = await Assert.ThrowsAsync<DomainException>(() => h.Stock.ApproveAsync(id, null));
        Assert.Equal(ErrorCodes.ApprovalRoleRequired, clerk.Code);
        h.User.Be(ApproverB);
        Assert.Equal(AdjustmentStatus.Posted, (await h.Stock.ApproveAsync(id, null)).Status);
    }
    // --- Price adjustments ------------------------------------------------------------------
    [Fact]
    public async Task PriceAdjustment_AppliesOnlyAfterTheSecondApproval_AndKeepsHistory()
    {
        var h = await Harness.CreateAsync();
        var dto = await h.Prices.CreateAsync(PriceRequest(flat: 120m));
        Assert.Equal(PriceAdjustmentStatus.PendingApproval, dto.Status);
        Assert.Equal(100m, (await h.Db.Items.AsNoTracking().FirstAsync()).SellingFlatPrice);
        h.User.Be(ApproverA);
        await h.Prices.ApproveAsync(dto.PriceAdjustmentId, null);
        Assert.Equal(100m, (await h.Db.Items.AsNoTracking().FirstAsync()).SellingFlatPrice);
        h.User.Be(ApproverB);
        var applied = await h.Prices.ApproveAsync(dto.PriceAdjustmentId, null);
        Assert.Equal(PriceAdjustmentStatus.Approved, applied.Status);
        Assert.Equal(120m, (await h.Db.Items.AsNoTracking().FirstAsync()).SellingFlatPrice);
        var history = Assert.Single(await h.Prices.ItemHistoryAsync(ItemId));
        Assert.Equal((100m, 120m, ApproverA, ApproverB, dto.DocNo), (history.OldFlatPrice, history.NewFlatPrice, history.ApprovedLevel1By, history.ApprovedLevel2By, history.DocNo));
    }
    [Fact]
    public async Task PriceAdjustment_ItemRepricedSinceTheRequest_IsRefusedAsStale()
    {
        var h = await Harness.CreateAsync();
        var id = (await h.Prices.CreateAsync(PriceRequest(flat: 120m))).PriceAdjustmentId;
        h.User.Be(ApproverA);
        await h.Prices.ApproveAsync(id, null);
        var item = await h.Db.Items.FirstAsync();
        item.SellingFlatPrice = 105m;            // someone changed it in between
        await h.Db.SaveChangesAsync();
        h.User.Be(ApproverB);
        var stale = await Assert.ThrowsAsync<DomainException>(() => h.Prices.ApproveAsync(id, null));
        Assert.Equal(ErrorCodes.PriceAdjustmentStale, stale.Code);
        Assert.Empty(await h.Prices.ItemHistoryAsync(ItemId));
    }
    [Fact]
    public async Task PriceAdjustment_OnePendingRequestPerItem()
    {
        var h = await Harness.CreateAsync();
        await h.Prices.CreateAsync(PriceRequest(flat: 120m));
        var second = await Assert.ThrowsAsync<DomainException>(() => h.Prices.CreateAsync(PriceRequest(flat: 130m)));
        Assert.Equal(ErrorCodes.PriceAdjustmentItemPending, second.Code);
    }
    [Theory]
    [InlineData(100, 120, 20)]
    [InlineData(100, 80, 20)]
    [InlineData(-1, 50, 100)]     // setting a price where there was none (-1 = no price)
    [InlineData(50, -1, 100)]     // clearing one
    [InlineData(40, 40, 0)]
    public void ChangePercent_MeasuresTheSizeOfAPriceChange(int oldPrice, int newPrice, int expected)
    {
        decimal? Price(int v) => v < 0 ? null : v;
        Assert.Equal(expected, PriceAdjustmentService.ChangePercent(Price(oldPrice), Price(newPrice)));
    }
    [Theory]
    [InlineData(2, 0, 5000, 2)]     // no threshold: always two
    [InlineData(2, 1000, 50, 1)]    // below threshold: one
    [InlineData(2, 1000, 1000, 2)]  // at threshold: two
    [InlineData(1, 1000, 5000, 1)]
    [InlineData(0, 0, 5000, 0)]
    public void RequiredLevels_FollowTheSettings(int configured, double threshold, double measure, int expected)
        => Assert.Equal(expected, ApprovalService.Levels(configured, (decimal)threshold, (decimal)measure));
    // --- helpers ------------------------------------------------------------------------------
    private static CreateAdjustmentRequest Request(decimal qty) => new()
    {
        WarehouseId = WarehouseId, BranchId = 1, ReasonCodeId = ReasonId,
        Lines = [new CreateAdjustmentLineInput { ItemId = ItemId, QtyDelta = qty }]
    };
    private static CreatePriceAdjustmentRequest PriceRequest(decimal flat) => new()
    {
        Reason = "Supplier price rise",
        Lines = [new PriceAdjustmentLineInput { ItemId = ItemId, NewMinPrice = 90m, NewMaxPrice = 150m, NewFlatPrice = flat }]
    };
    private sealed class Harness
    {
        public required ErpDbContext Db { get; init; }
        public required SwitchableUser User { get; init; }
        public required RecordingMutator Mutator { get; init; }
        public required FakeGeneralLedger Gl { get; init; }
        public required RecordingNotifications Notifications { get; init; }
        public required AdjustmentService Stock { get; init; }
        public required PriceAdjustmentService Prices { get; init; }
        public static async Task<Harness> CreateAsync(int stockLevels = 2, decimal stockThreshold = 0, string? level2Roles = null)
        {
            var db = new ErpDbContext(
                new DbContextOptionsBuilder<ErpDbContext>().UseInMemoryDatabase(Guid.NewGuid().ToString("N"), Root).Options,
                new TestCurrentUser(), new CurrentBranchContext(new TestCurrentUser()));
            db.Roles.AddRange(
                new Role { RoleId = 1, Code = "Requester", Name = "Requester" },
                new Role { RoleId = ApproverRoleId, Code = "Approver", Name = "Approver" },
                new Role { RoleId = ClerkRoleId, Code = "Clerk", Name = "Clerk" });
            db.Users.AddRange(
                new User { UserId = ERPCore.Domain.Entities.User.SystemUserId, Username = "system", DisplayName = "System" },
                new User { UserId = Requester, Username = "req", DisplayName = "Requester", RoleId = 1 },
                new User { UserId = ApproverA, Username = "a", DisplayName = "Approver A", RoleId = ApproverRoleId },
                new User { UserId = ApproverB, Username = "b", DisplayName = "Approver B", RoleId = ApproverRoleId },
                new User { UserId = Clerk, Username = "c", DisplayName = "Clerk", RoleId = ClerkRoleId });
            db.Permissions.AddRange(
                new Permission { PermissionId = 45, Code = "NAV:stock.adjustments" },
                new Permission { PermissionId = 58, Code = "NAV:products.price-adjustments" });
            foreach (var roleId in new[] { ApproverRoleId, ClerkRoleId })
            foreach (var permissionId in new[] { 45, 58 })
                db.RolePermissions.Add(new RolePermission { RoleId = roleId, PermissionId = permissionId, Actions = RolePermissionAction.All });
            db.RolePermissions.Add(new RolePermission { RoleId = 1, PermissionId = 45, Actions = RolePermissionAction.View | RolePermissionAction.Create });
            db.Branches.Add(new Branch { BranchId = 1, Code = "BR-001", Name = "Main" });
            db.Warehouses.Add(new Warehouse { WarehouseId = WarehouseId, Code = "WH-1", Name = "Main Store", BranchId = 1 });
            db.Uoms.Add(new Uom { UomId = 1, Name = "pcs" });
            db.Items.Add(new Item { ItemId = ItemId, Sku = "SKU-1", Name = "Cola", BaseUomId = 1, CategoryId = 1,
                SellingMinPrice = 90m, SellingMaxPrice = 150m, SellingFlatPrice = 100m });
            db.ReasonCodes.Add(new ReasonCode { ReasonCodeId = ReasonId, Code = "DMG", Description = "Damage", Context = ReasonContext.Adjustment });
            db.ApprovalConfig.Add(new ApprovalConfig
            {
                ApprovalConfigId = ApprovalConfig.SingletonId, StockAdjustmentLevels = stockLevels,
                StockAdjustmentLevel2ThresholdValue = stockThreshold, PriceAdjustmentLevels = 2, Level2RoleCodes = level2Roles
            });
            await db.SaveChangesAsync();
            var user = new SwitchableUser(Requester, "Requester");
            var uow = new PassThroughUnitOfWork(db);
            var notifications = new RecordingNotifications();
            var approvals = new ApprovalService(
                new Repository<ApprovalConfig>(db), new Repository<DocumentApproval>(db), new Repository<User>(db),
                new Repository<RolePermission>(db), user, notifications, uow);
            var gl = new FakeGeneralLedger();
            var mutator = new RecordingMutator();
            var numbers = new FakeNumberSequence();
            var stock = new AdjustmentService(
                new Repository<StockAdjustment>(db), new Repository<Warehouse>(db), new Repository<Item>(db),
                new Repository<ReasonCode>(db), new Repository<StockLedger>(db), mutator, new FixedValuation(),
                numbers, user, new FakeBranchConfig(), notifications, approvals, uow, db, gl,
                new ConfigurationBuilder().Build(),
                new SerialTrackingService(new Repository<Serial>(db), new Repository<SerialMovement>(db), new Repository<StockLayer>(db),
                    new Repository<ProductConfig>(db), user));
            var prices = new PriceAdjustmentService(
                new Repository<PriceAdjustment>(db), new Repository<Item>(db), new Repository<ItemPriceHistory>(db),
                new Repository<User>(db), new Repository<ApprovalConfig>(db), approvals, notifications, numbers, user, uow);
            return new Harness { Db = db, User = user, Mutator = mutator, Gl = gl, Notifications = notifications, Stock = stock, Prices = prices };
        }
    }
    /// <summary>A signed-in user whose identity the test switches between steps.</summary>
    private sealed class SwitchableUser(int userId, string roleCode) : ICurrentUser
    {
        private static readonly Dictionary<int, string> Roles = new()
        {
            [Requester] = "Requester", [ApproverA] = "Approver", [ApproverB] = "Approver", [Clerk] = "Clerk"
        };
        public int AuditUserId { get; private set; } = userId;
        public string? RoleCode { get; private set; } = roleCode;
        public string UserId => AuditUserId.ToString();
        public bool IsAuthenticated => true;
        public bool IsAdmin => false;
        public int? BranchId => null;
        public void Be(int userId)
        {
            AuditUserId = userId;
            RoleCode = Roles[userId];
        }
    }
    /// <summary>Records what would be posted to stock; every unit is worth 10.00.</summary>
    private sealed class RecordingMutator : IStockMutator
    {
        public List<IReadOnlyList<StockDelta>> Calls { get; } = new();
        public Task<IReadOnlyList<StockLedger>> ApplyAsync(int warehouseId, string sourceDocType, int sourceDocId, DateTime now,
            IReadOnlyList<StockDelta> deltas, CancellationToken ct = default)
        {
            Calls.Add(deltas);
            IReadOnlyList<StockLedger> refs = deltas.Select(d => new StockLedger
            {
                ItemId = d.ItemId, WarehouseId = warehouseId, QtyBase = Math.Abs(d.QtyDelta), UnitCost = 10m, Value = Math.Abs(d.QtyDelta) * 10m,
                Direction = d.QtyDelta < 0 ? Direction.Out : Direction.In, SourceDocType = sourceDocType, SourceDocId = sourceDocId, CreatedAt = now
            }).ToList();
            return Task.FromResult(refs);
        }
    }
    /// <summary>10 units on hand worth 100.00 — 10.00 each, which prices requests for the threshold.</summary>
    private sealed class FixedValuation : IFifoCostingService
    {
        public Task<StockValuationDto> GetValuationAsync(int itemId, int warehouseId, CancellationToken ct = default)
            => Task.FromResult(new StockValuationDto(itemId, warehouseId, [], 10m, 100m, "LKR", "FIFO"));
        public Task<StockLayer> CreateInboundLayerAsync(int itemId, int warehouseId, int? batchId, int? serialId, int? grnLineId,
            decimal qtyBase, decimal unitCost, DateTime receiptDate, CancellationToken ct = default) => throw new NotSupportedException();
        public Task<IReadOnlyList<ConsumedSegment>> ConsumeAsync(int itemId, int warehouseId, int? batchId, decimal qtyBase, CancellationToken ct = default,
            bool allowShortfall = false, IReadOnlyCollection<int>? serialIds = null) => throw new NotSupportedException();
        public Task<IReadOnlyList<BatchAllocation>> SuggestBatchesAsync(int itemId, int warehouseId, decimal qtyBase, CancellationToken ct = default)
            => throw new NotSupportedException();
        public Task<StockLedger> PostLedgerAsync(int itemId, int warehouseId, int? binId, int? batchId, int? serialId, int userId,
            Direction direction, decimal qtyBase, decimal unitCost, decimal runningBalance, string sourceDocType, int sourceDocId,
            DateTime createdAt, CancellationToken ct = default, decimal? valueOverride = null) => throw new NotSupportedException();
        public Task<decimal> GetOnHandAsync(int itemId, int warehouseId, CancellationToken ct = default) => Task.FromResult(10m);
    }
    private sealed class RecordingNotifications : INotificationService
    {
        public List<(IReadOnlyList<int> UserIds, string ModuleKey, string Message)> Targeted { get; } = new();
        public Task RaiseAsync(string moduleKey, string title, string message, string? relatedEntityType = null, int? relatedEntityId = null,
            CancellationToken ct = default) => Task.CompletedTask;
        public Task NotifyUsersAsync(IEnumerable<int> userIds, string moduleKey, string title, string message,
            string? relatedEntityType = null, int? relatedEntityId = null, CancellationToken ct = default)
        {
            Targeted.Add((userIds.ToList(), moduleKey, message));
            return Task.CompletedTask;
        }
        public Task<NotificationFeedDto> GetFeedAsync(int userId, int take = 20, CancellationToken ct = default) => throw new NotSupportedException();
        public Task MarkAllReadAsync(int userId, CancellationToken ct = default) => throw new NotSupportedException();
    }
 }
@@ -8,7 +8,7 @@
  </PropertyGroup>
  <ItemGroup>
-    <PackageReference Include="Microsoft.EntityFrameworkCore.InMemory" Version="9.0.20" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.InMemory" Version="10.0.9" />
    <PackageReference Include="coverlet.collector" Version="6.0.4" />
    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.14.1" />
    <PackageReference Include="xunit" Version="2.9.3" />
@@ -1,151 +0,0 @@
 using ERPCore.Infra.Gl;
 using ERPCore.Services.Gl;
 using ERPCore.Services.Interfaces;
 using ERPCore.System.Time;
 using ERPCore.Tests.TestSupport;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging.Abstractions;
 namespace ERPCore.Tests;
 /// <summary>
 /// The validator is advisory: enforcement lives in <see cref="ERPCore.Services.GlAccountConfigService"/>,
 /// which refuses to store a bad mapping in the first place. So the behaviour that matters here is that
 /// it <b>cannot abort startup</b>. An earlier revision threw on a missing code and core-dumped
 /// erpcore.service on deploy (2026-10-07), turning a long-standing data mismatch into an outage.
 /// </summary>
 public class GlAccountCodeValidatorTests
 {
    [Fact]
    public async Task StartAsync_Succeeds_WhenEveryMappedCodeExistsInGl()
    {
        var validator = CreateValidator(
            new(),
            new StubGeneralLedgerService([
                StubGeneralLedgerService.Postable("1100"),
                StubGeneralLedgerService.Postable("2000")
            ]),
            (GlAccountRole.Inventory, "1100"), (GlAccountRole.Clearing, "2000"));
        await validator.StartAsync(CancellationToken.None);
    }
    [Fact]
    public async Task StartAsync_DoesNotThrow_WhenMappedCodesAreMissingFromGl()
    {
        var validator = CreateValidator(
            new(),
            new StubGeneralLedgerService([StubGeneralLedgerService.Postable("1000-01")]),
            (GlAccountRole.Inventory, "1100"), (GlAccountRole.Cash, "1000-01"));
        await validator.StartAsync(CancellationToken.None);
    }
    [Fact]
    public async Task StartAsync_Throws_AndNamesEveryMissingCode_WhenConfiguredToFail()
    {
        var validator = CreateValidator(
            new() { ["GeneralLedgerService:FailOnMissingAccountCodes"] = "true" },
            new StubGeneralLedgerService([StubGeneralLedgerService.Postable("1100")]),
            (GlAccountRole.Inventory, "1100"),
            (GlAccountRole.Cash, "1000-01"),
            (GlAccountRole.InventoryLoss, "5100"));
        var ex = await Assert.ThrowsAsync<InvalidOperationException>(
            () => validator.StartAsync(CancellationToken.None));
        Assert.Contains("1000-01", ex.Message);
        Assert.Contains("5100", ex.Message);
        Assert.Contains("2 of 3", ex.Message);
    }
    /// <summary>
    /// If GL's /accounts shape ever changes, the reader yields nothing. Treating that as
    /// "everything is missing" would refuse to start on a contract change.
    /// </summary>
    [Fact]
    public async Task StartAsync_DoesNotThrow_WhenGlReturnsNoAccountsAtAll()
    {
        var validator = CreateValidator(
            new() { ["GeneralLedgerService:FailOnMissingAccountCodes"] = "true" },
            new StubGeneralLedgerService([]),
            (GlAccountRole.Inventory, "1100"));
        await validator.StartAsync(CancellationToken.None);
    }
    /// <summary>
    /// The catch filter once matched only DomainException/OperationCanceledException, so anything
    /// else — a parse failure, a null-items NRE in the reader, a database hiccup reading the
    /// mapping — escaped a hosted service and aborted the host.
    /// </summary>
    [Theory]
    [MemberData(nameof(UnexpectedFailures))]
    public async Task StartAsync_DoesNotThrow_OnAnyUnexpectedFailure(Exception failure)
    {
        var validator = CreateValidator(
            new() { ["GeneralLedgerService:FailOnMissingAccountCodes"] = "true" },
            new StubGeneralLedgerService(failure),
            (GlAccountRole.Inventory, "1100"));
        await validator.StartAsync(CancellationToken.None);
    }
    public static TheoryData<Exception> UnexpectedFailures() =>
    [
        StubGeneralLedgerService.Unreachable(),
        new NullReferenceException("items was null"),
        new global::System.Text.Json.JsonException("unexpected shape"),
        new InvalidOperationException("something else entirely"),
        new HttpRequestException("connection reset"),
        new OperationCanceledException(),
    ];
    [Fact]
    public async Task StartAsync_SkipsTheGlCall_WhenNothingIsMapped()
    {
        var gl = new StubGeneralLedgerService([StubGeneralLedgerService.Postable("1100")]);
        var validator = CreateValidator(new(), gl);
        await validator.StartAsync(CancellationToken.None);
        Assert.Equal(0, gl.Calls);
    }
    /// <summary>Duplicate codes across roles are one account to verify, not several.</summary>
    [Fact]
    public async Task StartAsync_DeduplicatesCodesSharedBySeveralRoles()
    {
        var gl = new StubGeneralLedgerService([StubGeneralLedgerService.Postable("1100")]);
        var validator = CreateValidator(
            new() { ["GeneralLedgerService:FailOnMissingAccountCodes"] = "true" },
            gl,
            (GlAccountRole.Inventory, "1100"), (GlAccountRole.InventoryGain, "1100"));
        await validator.StartAsync(CancellationToken.None);
        Assert.Equal(1, gl.Calls);
    }
    /// <summary>Asia/Colombo is UTC+05:30, so 20:00 UTC on the 31st is already the 1st locally.</summary>
    [Fact]
    public void BusinessClock_MapsAUtcInstantToTheLocalBusinessDay()
    {
        Assert.Equal(new DateOnly(2026, 11, 1), BusinessClock.ToBusinessDate(new DateTime(2026, 10, 31, 20, 0, 0, DateTimeKind.Utc)));
        Assert.Equal(new DateOnly(2026, 10, 31), BusinessClock.ToBusinessDate(new DateTime(2026, 10, 31, 18, 0, 0, DateTimeKind.Utc)));
        Assert.Equal(new DateOnly(2026, 10, 31), BusinessClock.ToBusinessDate(new DateTime(2026, 10, 31, 18, 29, 59, DateTimeKind.Utc)));
        Assert.Equal(new DateOnly(2026, 11, 1), BusinessClock.ToBusinessDate(new DateTime(2026, 10, 31, 18, 30, 0, DateTimeKind.Utc)));
    }
    private static GlAccountCodeValidator CreateValidator(
        Dictionary<string, string?> settings, StubGeneralLedgerService gl, params (GlAccountRole, string?)[] mapping)
    {
        var configuration = new ConfigurationBuilder().AddInMemoryCollection(settings).Build();
        var services = new ServiceCollection()
            .AddScoped<IGeneralLedgerService>(_ => gl)
            .AddScoped<IGlAccountConfigService>(_ => new StubGlAccountConfigService(mapping))
            .BuildServiceProvider();
        return new GlAccountCodeValidator(services, configuration, NullLogger<GlAccountCodeValidator>.Instance);
    }
 }
@@ -1,234 +0,0 @@
 using ERPCore.Domain.Entities;
 using ERPCore.Dtos.Config;
 using ERPCore.Infra.Persistence;
 using ERPCore.Repositories;
 using ERPCore.Services;
 using ERPCore.Services.Gl;
 using ERPCore.Services.Interfaces;
 using ERPCore.System.Errors;
 using ERPCore.Tests.TestSupport;
 namespace ERPCore.Tests;
 /// <summary>
 /// The point of this service is that a mapping GL cannot post to never reaches the database.
 /// Validation at the point of entry is what the old appsettings approach could not do: those codes
 /// were only ever checked at boot, and on 2026-10-07 eleven of twelve turned out never to have
 /// existed in GL at all.
 /// </summary>
 public class GlAccountConfigServiceTests
 {
    [Fact]
    public async Task UpdateAsync_PersistsAMappingGlCanPostTo()
    {
        await using var db = await CreateSeededContextAsync();
        var gl = new StubGeneralLedgerService([
            StubGeneralLedgerService.Postable("1100", "Inventory"),
            StubGeneralLedgerService.Postable("2000", "GRNI")
        ]);
        var service = CreateService(db, gl);
        var before = (await service.GetAsync()).RowVersion;
        var result = await service.UpdateAsync(
            new UpdateGlAccountConfigRequest { InventoryAccountCode = "1100", ClearingAccountCode = "2000" }, before);
        Assert.True(result.RowVersion > before);
        var codes = await CreateService(db, gl).GetCodesAsync();
        Assert.Equal("1100", codes[GlAccountRole.Inventory]);
        Assert.Equal("2000", codes[GlAccountRole.Clearing]);
    }
    [Fact]
    public async Task UpdateAsync_RejectsACodeGlDoesNotHave_AndNamesIt()
    {
        await using var db = await CreateSeededContextAsync();
        var service = CreateService(db, new StubGeneralLedgerService([StubGeneralLedgerService.Postable("1100")]));
        var rowVersion = (await service.GetAsync()).RowVersion;
        var ex = await Assert.ThrowsAsync<DomainException>(() => service.UpdateAsync(
            new UpdateGlAccountConfigRequest { InventoryAccountCode = "1100", ClearingAccountCode = "9999" }, rowVersion));
        Assert.Equal(ErrorCodes.GlAccountInvalid, ex.Code);
        Assert.Equal(422, ex.StatusCode);
        Assert.Contains("9999", ex.Message);
        Assert.Contains("Clearing", ex.Message);
        await AssertNothingStoredAsync(db);
    }
    /// <summary>
    /// GL rejects a journal line against a non-postable account, so storing one only defers the
    /// failure to posting time. The auto-created <c>1000</c> Bank/Cash header is exactly this trap.
    /// </summary>
    [Fact]
    public async Task UpdateAsync_RejectsANonPostableAccount()
    {
        await using var db = await CreateSeededContextAsync();
        var service = CreateService(db, new StubGeneralLedgerService([
            StubGeneralLedgerService.NotPostable("1000", "Bank and Cash")
        ]));
        var rowVersion = (await service.GetAsync()).RowVersion;
        var ex = await Assert.ThrowsAsync<DomainException>(() => service.UpdateAsync(
            new UpdateGlAccountConfigRequest { CashAccountCode = "1000" }, rowVersion));
        Assert.Equal(ErrorCodes.GlAccountInvalid, ex.Code);
        Assert.Contains("not postable", ex.Message);
        await AssertNothingStoredAsync(db);
    }
    /// <summary>Fails closed, deliberately opposite to the startup validator: an unverified mapping is not a valid one.</summary>
    [Fact]
    public async Task UpdateAsync_RefusesToSaveWhenGlIsUnreachable()
    {
        await using var db = await CreateSeededContextAsync();
        var service = CreateService(db, new StubGeneralLedgerService(StubGeneralLedgerService.Unreachable()));
        var ex = await Assert.ThrowsAsync<DomainException>(() => service.UpdateAsync(
            new UpdateGlAccountConfigRequest { InventoryAccountCode = "1100" }, 1));
        Assert.Equal(ErrorCodes.GlServiceUnavailable, ex.Code);
        await AssertNothingStoredAsync(db);
    }
    [Fact]
    public async Task UpdateAsync_RefusesToSaveAgainstAnEmptyChartOfAccounts()
    {
        await using var db = await CreateSeededContextAsync();
        var service = CreateService(db, new StubGeneralLedgerService([]));
        var rowVersion = (await service.GetAsync()).RowVersion;
        var ex = await Assert.ThrowsAsync<DomainException>(() => service.UpdateAsync(
            new UpdateGlAccountConfigRequest { InventoryAccountCode = "1100" }, rowVersion));
        Assert.Equal(ErrorCodes.GlAccountInvalid, ex.Code);
        Assert.Equal(503, ex.StatusCode);
    }
    [Fact]
    public async Task UpdateAsync_RejectsAStaleIfMatch()
    {
        await using var db = await CreateSeededContextAsync();
        var service = CreateService(db, new StubGeneralLedgerService([StubGeneralLedgerService.Postable("1100")]));
        var ex = await Assert.ThrowsAsync<DomainException>(() => service.UpdateAsync(
            new UpdateGlAccountConfigRequest { InventoryAccountCode = "1100" }, expectedRowVersion: 9999));
        Assert.Equal(ErrorCodes.ConcurrencyConflict, ex.Code);
        Assert.Equal(412, ex.StatusCode);
    }
    /// <summary>An empty string clears a role rather than storing "" and posting it to GL.</summary>
    [Fact]
    public async Task UpdateAsync_TreatsBlankAsCleared()
    {
        await using var db = await CreateSeededContextAsync();
        var gl = new StubGeneralLedgerService([StubGeneralLedgerService.Postable("1100")]);
        var service = CreateService(db, gl);
        var rowVersion = (await service.GetAsync()).RowVersion;
        await service.UpdateAsync(new UpdateGlAccountConfigRequest { InventoryAccountCode = "   " }, rowVersion);
        var codes = await CreateService(db, gl).GetCodesAsync();
        Assert.Null(codes.GetOrNull(GlAccountRole.Inventory));
    }
    /// <summary>Reading an unmapped role names the role, instead of posting "" and letting GL 404.</summary>
    [Fact]
    public async Task GetCodesAsync_ThrowsNamingTheRole_WhenUnmapped()
    {
        await using var db = await CreateSeededContextAsync();
        var service = CreateService(db, new StubGeneralLedgerService([]));
        var codes = await service.GetCodesAsync();
        var ex = Assert.Throws<DomainException>(() => codes[GlAccountRole.Cogs]);
        Assert.Equal(ErrorCodes.GlAccountNotConfigured, ex.Code);
        Assert.Contains("Cogs", ex.Message);
    }
    /// <summary>One request can post through several services; they should not each re-read the row.</summary>
    [Fact]
    public async Task GetCodesAsync_ReadsOncePerScope()
    {
        await using var db = await CreateSeededContextAsync();
        var service = CreateService(db, new StubGeneralLedgerService([]));
        var first = await service.GetCodesAsync();
        var second = await service.GetCodesAsync();
        Assert.Same(first, second);
    }
    /// <summary>GL being down must not stop the saved mapping from rendering on the settings screen.</summary>
    [Fact]
    public async Task GetAsync_StillReturnsTheMapping_WhenGlIsUnreachable()
    {
        await using var db = await CreateSeededContextAsync(c => c.InventoryAccountCode = "1100");
        var service = CreateService(db, new StubGeneralLedgerService(StubGeneralLedgerService.Unreachable()));
        var result = await service.GetAsync();
        Assert.True(result.Value.GlUnavailable);
        Assert.Empty(result.Value.Options);
        var inventory = result.Value.Mappings.Single(m => m.Role == nameof(GlAccountRole.Inventory));
        Assert.Equal("1100", inventory.AccountCode);
    }
    /// <summary>The 2026-10-07 state: a stored code GL does not have is shown flagged, not blank.</summary>
    [Fact]
    public async Task GetAsync_FlagsAStoredCodeThatGlDoesNotHave()
    {
        await using var db = await CreateSeededContextAsync(c =>
        {
            c.InventoryAccountCode = "1100";
            c.CashAccountCode = "1000-01";
        });
        var service = CreateService(db, new StubGeneralLedgerService([
            StubGeneralLedgerService.Postable("1000-01", "Cash in Hand")
        ]));
        var result = await service.GetAsync();
        Assert.False(result.Value.Mappings.Single(m => m.Role == nameof(GlAccountRole.Inventory)).ExistsInGl);
        Assert.True(result.Value.Mappings.Single(m => m.Role == nameof(GlAccountRole.Cash)).ExistsInGl);
    }
    /// <summary>The picker must only offer what validation will accept.</summary>
    [Fact]
    public async Task GetAsync_OffersOnlyPostableActiveAccounts()
    {
        await using var db = await CreateSeededContextAsync();
        var service = CreateService(db, new StubGeneralLedgerService([
            StubGeneralLedgerService.Postable("1100", "Inventory"),
            StubGeneralLedgerService.NotPostable("1000", "Bank and Cash"),
            new GlAccount("1200", "Retired", 1, true, false)
        ]));
        var options = (await service.GetAsync()).Value.Options;
        Assert.Equal(["1100"], options.Select(o => o.AccountCode));
    }
    private static async Task AssertNothingStoredAsync(ErpDbContext db)
    {
        var row = await new Repository<GlAccountConfig>(db).GetByIdAsync(GlAccountConfig.SingletonId);
        Assert.Null(row!.InventoryAccountCode);
        Assert.Null(row.ClearingAccountCode);
        Assert.Null(row.CashAccountCode);
    }
    private static async Task<ErpDbContext> CreateSeededContextAsync(Action<GlAccountConfig>? configure = null)
    {
        var db = NotificationConfigTestSupport.CreateContext(Guid.NewGuid().ToString("N"));
        db.Users.Add(new User { UserId = User.SystemUserId, Username = "system", DisplayName = "System" });
        var config = new GlAccountConfig { ConfigId = GlAccountConfig.SingletonId };
        configure?.Invoke(config);
        db.GlAccountConfig.Add(config);
        await db.SaveChangesAsync();
        return db;
    }
    private static GlAccountConfigService CreateService(ErpDbContext db, IGeneralLedgerService gl) =>
        new(new Repository<GlAccountConfig>(db), gl, new TestCurrentUser(), new ERPCore.Infra.UoW.UnitOfWork(db));
 }
@@ -1,366 +0,0 @@
 using ERPCore.Domain.Entities;
 using ERPCore.Domain.Enums;
 using ERPCore.Infra.Auth;
 using ERPCore.Infra.Persistence;
 using ERPCore.Repositories;
 using ERPCore.Services;
 using ERPCore.Services.Stock;
 using ERPCore.System.Errors;
 using ERPCore.Tests.TestSupport;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Storage;
 namespace ERPCore.Tests;
 /// <summary>
 /// Serial/batch rules from docs/ITEM_TRACKING_PLAN.md that live outside the MariaDB-only FIFO
 /// SQL: the sales-line check (<see cref="SalesDomainService.ValidateLineTrackingAsync"/>) and the
 /// shared stock-document rules (<see cref="SerialTrackingService"/>).
 /// </summary>
 public class ItemTrackingTests
 {
    private static readonly InMemoryDatabaseRoot Root = new();
    private const int Wh1 = 1;
    private const int Wh2 = 2;
    private const int SerialItemId = 10;
    private const int BatchItemId = 20;
    private const int PlainItemId = 30;
    // --- sales line validation --------------------------------------------------------------
    [Fact]
    public async Task SalesLine_SerialItem_RequiresOneSerialPerUnit()
    {
        await using var db = await SeedAsync();
        var sales = CreateSalesDomain(db);
        var ex = await Assert.ThrowsAsync<DomainException>(() =>
            sales.ValidateLineTrackingAsync(SerialItemId, Wh1, 2, null, new[] { 1 }, new HashSet<int>()));
        Assert.Equal(ErrorCodes.TrackingRequired, ex.Code);
    }
    [Fact]
    public async Task SalesLine_SerialItem_WithoutSerials_IsRejected_WhenNoPreTrackingStockIsLeft()
    {
        await using var db = await SeedAsync();
        var sales = CreateSalesDomain(db);
        var ex = await Assert.ThrowsAsync<DomainException>(() =>
            sales.ValidateLineTrackingAsync(SerialItemId, Wh1, 1, null, null, new HashSet<int>()));
        Assert.Equal(ErrorCodes.TrackingRequired, ex.Code);
    }
    [Fact]
    public async Task SalesLine_SerialItem_WithoutSerials_IsAllowed_FromPreTrackingStock()
    {
        await using var db = await SeedAsync();
        // D6: stock received before serial capture — a layer with no serial.
        db.StockLayers.Add(new StockLayer { ItemId = SerialItemId, WarehouseId = Wh1, QtyReceived = 3, QtyRemaining = 3, UnitCost = 10, ReceiptDate = DateTime.UtcNow });
        await db.SaveChangesAsync();
        var sales = CreateSalesDomain(db);
        var serials = await sales.ValidateLineTrackingAsync(SerialItemId, Wh1, 2, null, null, new HashSet<int>());
        Assert.Empty(serials);
    }
    [Fact]
    public async Task SalesLine_Serial_AtAnotherWarehouse_IsNotAvailable()
    {
        await using var db = await SeedAsync();
        var sales = CreateSalesDomain(db);
        // Serial 3 is in stock at warehouse 2.
        var ex = await Assert.ThrowsAsync<DomainException>(() =>
            sales.ValidateLineTrackingAsync(SerialItemId, Wh1, 1, null, new[] { 3 }, new HashSet<int>()));
        Assert.Equal(ErrorCodes.SerialNotAvailable, ex.Code);
    }
    [Fact]
    public async Task SalesLine_SoldSerial_IsNotAvailable()
    {
        await using var db = await SeedAsync();
        var sales = CreateSalesDomain(db);
        var ex = await Assert.ThrowsAsync<DomainException>(() =>
            sales.ValidateLineTrackingAsync(SerialItemId, Wh1, 1, null, new[] { 4 }, new HashSet<int>()));
        Assert.Equal(ErrorCodes.SerialNotAvailable, ex.Code);
    }
    [Fact]
    public async Task SalesLine_SameSerialOnTwoLines_IsADuplicate()
    {
        await using var db = await SeedAsync();
        var sales = CreateSalesDomain(db);
        var documentSerials = new HashSet<int>();
        await sales.ValidateLineTrackingAsync(SerialItemId, Wh1, 1, null, new[] { 1 }, documentSerials);
        var ex = await Assert.ThrowsAsync<DomainException>(() =>
            sales.ValidateLineTrackingAsync(SerialItemId, Wh1, 1, null, new[] { 1 }, documentSerials));
        Assert.Equal(ErrorCodes.SerialDuplicate, ex.Code);
    }
    [Fact]
    public async Task SalesLine_ValidSerials_AreReturned()
    {
        await using var db = await SeedAsync();
        var sales = CreateSalesDomain(db);
        var serials = await sales.ValidateLineTrackingAsync(SerialItemId, Wh1, 2, null, new[] { 1, 2 }, new HashSet<int>());
        Assert.Equal(new[] { 1, 2 }, serials.Select(s => s.SerialId).OrderBy(i => i));
    }
    [Fact]
    public async Task SalesLine_UntrackedItem_RejectsSerials()
    {
        await using var db = await SeedAsync();
        var sales = CreateSalesDomain(db);
        var ex = await Assert.ThrowsAsync<DomainException>(() =>
            sales.ValidateLineTrackingAsync(PlainItemId, Wh1, 1, null, new[] { 1 }, new HashSet<int>()));
        Assert.Equal(ErrorCodes.Validation, ex.Code);
    }
    [Fact]
    public async Task SalesLine_ExpiredBatch_IsBlocked()
    {
        await using var db = await SeedAsync();
        var sales = CreateSalesDomain(db);
        var ex = await Assert.ThrowsAsync<DomainException>(() =>
            sales.ValidateLineTrackingAsync(BatchItemId, Wh1, 1, 101, null, new HashSet<int>()));
        Assert.Equal(ErrorCodes.ExpiredBatchBlocked, ex.Code);
    }
    [Fact]
    public async Task SalesLine_BatchOfAnotherItem_IsRejected()
    {
        await using var db = await SeedAsync();
        var sales = CreateSalesDomain(db);
        var ex = await Assert.ThrowsAsync<DomainException>(() =>
            sales.ValidateLineTrackingAsync(PlainItemId, Wh1, 1, 100, null, new HashSet<int>()));
        Assert.Equal(ErrorCodes.Validation, ex.Code);
    }
    // --- stock documents (transfers / adjustments / purchase returns) ------------------------
    [Fact]
    public async Task Outbound_DamagedSerial_OnlyWhenAllowed()
    {
        await using var db = await SeedAsync();
        var tracking = CreateSerialTracking(db);
        var item = await db.Items.FirstAsync(i => i.ItemId == SerialItemId);
        // Serial 5 is Damaged at warehouse 1: a transfer (InStock only) refuses it...
        var ex = await Assert.ThrowsAsync<DomainException>(() => tracking.ResolveOutboundAsync(
            item, Wh1, 1, new[] { 5 }, new HashSet<int>(), new[] { SerialStatus.InStock }));
        Assert.Equal(ErrorCodes.SerialNotAvailable, ex.Code);
        // ...a write-off or purchase return (InStock or Damaged) takes it.
        var serials = await tracking.ResolveOutboundAsync(
            item, Wh1, 1, new[] { 5 }, new HashSet<int>(), new[] { SerialStatus.InStock, SerialStatus.Damaged });
        Assert.Single(serials);
    }
    [Fact]
    public async Task Inbound_SerialAlreadyInStock_IsADuplicate()
    {
        await using var db = await SeedAsync();
        var tracking = CreateSerialTracking(db);
        var item = await db.Items.FirstAsync(i => i.ItemId == SerialItemId);
        var ex = await Assert.ThrowsAsync<DomainException>(() => tracking.ResolveInboundAsync(
            item, Wh1, 1, new[] { "SN-1" }, new HashSet<string>()));
        Assert.Equal(ErrorCodes.SerialDuplicate, ex.Code);
    }
    [Fact]
    public async Task Inbound_FractionalQty_IsRejected_ForSerialItems()
    {
        await using var db = await SeedAsync();
        var tracking = CreateSerialTracking(db);
        var item = await db.Items.FirstAsync(i => i.ItemId == SerialItemId);
        var ex = await Assert.ThrowsAsync<DomainException>(() => tracking.ResolveInboundAsync(
            item, Wh1, 1.5m, new[] { "SN-NEW" }, new HashSet<string>()));
        Assert.Equal(ErrorCodes.Validation, ex.Code);
    }
    [Fact]
    public async Task Inbound_NewAndSoldSerials_AreCreatedOrBroughtBack()
    {
        await using var db = await SeedAsync();
        var tracking = CreateSerialTracking(db);
        var item = await db.Items.FirstAsync(i => i.ItemId == SerialItemId);
        // SN-4 is Sold (out of stock) — it comes back; SN-NEW does not exist — it is created.
        var serials = await tracking.ResolveInboundAsync(item, Wh1, 2, new[] { "SN-4", "SN-NEW" }, new HashSet<string>());
        await tracking.MoveAsync(serials, SerialStatus.InStock, Wh1, null, "ADJ", 1, DateTime.UtcNow);
        await db.SaveChangesAsync();
        var all = await db.Serials.Where(s => s.ItemId == SerialItemId && (s.SerialNo == "SN-4" || s.SerialNo == "SN-NEW")).ToListAsync();
        Assert.All(all, s => Assert.Equal(SerialStatus.InStock, s.Status));
        Assert.All(all, s => Assert.Equal(Wh1, s.WarehouseId));
        Assert.Equal(2, await db.SerialMovements.CountAsync(m => m.SourceDocType == "ADJ"));
    }
    [Fact]
    public async Task Move_RecordsHistory_WithPreviousWarehouse()
    {
        await using var db = await SeedAsync();
        var tracking = CreateSerialTracking(db);
        var serial = await db.Serials.FirstAsync(s => s.SerialId == 1);
        await tracking.MoveAsync(new[] { serial }, SerialStatus.InTransit, null, null, "TRF", 7, DateTime.UtcNow);
        await db.SaveChangesAsync();
        var movement = await db.SerialMovements.SingleAsync(m => m.SerialId == 1);
        Assert.Equal(SerialStatus.InTransit, movement.Status);
        Assert.Equal(Wh1, movement.FromWarehouseId);
        Assert.Null(movement.WarehouseId);
        Assert.Null(serial.WarehouseId);
    }
    // --- auto-generated serial numbers -------------------------------------------------------
    [Fact]
    public async Task NextNumbers_ContinueAfterHighestUsed_AndSkipDraftGrnNumbers()
    {
        await using var db = await SeedAsync();
        db.Serials.Add(new Serial { SerialId = 50, ItemId = SerialItemId, SerialNo = "PH-0041", Status = SerialStatus.Sold });
        // A draft GRN line already holds PH-0042 (not yet a Serial).
        db.GrnLines.Add(new GrnLine { GrnLineId = 900, GrnId = 1, ItemId = SerialItemId, Qty = 1,
            Serials = { new GrnLineSerial { SerialNo = "PH-0042" } } });
        await db.SaveChangesAsync();
        var tracking = new ItemTrackingService(db, null!);
        var next = await tracking.NextSerialNumbersAsync(SerialItemId, "PH-", 3);
        Assert.Equal(new[] { "PH-0043", "PH-0044", "PH-0045" }, next);
    }
    [Fact]
    public async Task NextNumbers_StartAtOne_ForANewPrefix_AndIgnoreOtherItems()
    {
        await using var db = await SeedAsync();
        db.Serials.Add(new Serial { SerialId = 51, ItemId = PlainItemId, SerialNo = "NEW-0099", Status = SerialStatus.InStock });
        await db.SaveChangesAsync();
        var tracking = new ItemTrackingService(db, null!);
        var next = await tracking.NextSerialNumbersAsync(SerialItemId, "NEW-", 2);
        Assert.Equal(new[] { "NEW-0001", "NEW-0002" }, next);
    }
    [Fact]
    public async Task NextNumbers_RejectsTooMany()
    {
        await using var db = await SeedAsync();
        var tracking = new ItemTrackingService(db, null!);
        var ex = await Assert.ThrowsAsync<DomainException>(() => tracking.NextSerialNumbersAsync(SerialItemId, "X-", 5000));
        Assert.Equal(ErrorCodes.Validation, ex.Code);
    }
    // --- fixtures ---------------------------------------------------------------------------
    private static async Task<ErpDbContext> SeedAsync()
    {
        var db = CreateContext();
        db.Items.AddRange(
            new Item { ItemId = SerialItemId, Sku = "SER-1", Name = "Phone", CategoryId = 1, BaseUomId = 1, StockNature = StockNature.Stocked, TrackingMode = TrackingMode.Serial },
            new Item { ItemId = BatchItemId, Sku = "BAT-1", Name = "Milk", CategoryId = 1, BaseUomId = 1, StockNature = StockNature.Stocked, TrackingMode = TrackingMode.Batch },
            new Item { ItemId = PlainItemId, Sku = "PLN-1", Name = "Bolt", CategoryId = 1, BaseUomId = 1, StockNature = StockNature.Stocked, TrackingMode = TrackingMode.None });
        db.Batches.AddRange(
            new Batch { BatchId = 100, ItemId = BatchItemId, BatchNo = "B-OK", ExpiryDate = DateOnly.FromDateTime(DateTime.UtcNow).AddDays(30) },
            new Batch { BatchId = 101, ItemId = BatchItemId, BatchNo = "B-EXP", ExpiryDate = DateOnly.FromDateTime(DateTime.UtcNow).AddDays(-1) });
        db.Serials.AddRange(
            new Serial { SerialId = 1, ItemId = SerialItemId, SerialNo = "SN-1", Status = SerialStatus.InStock, WarehouseId = Wh1 },
            new Serial { SerialId = 2, ItemId = SerialItemId, SerialNo = "SN-2", Status = SerialStatus.InStock, WarehouseId = Wh1 },
            new Serial { SerialId = 3, ItemId = SerialItemId, SerialNo = "SN-3", Status = SerialStatus.InStock, WarehouseId = Wh2 },
            new Serial { SerialId = 4, ItemId = SerialItemId, SerialNo = "SN-4", Status = SerialStatus.Sold, WarehouseId = null },
            new Serial { SerialId = 5, ItemId = SerialItemId, SerialNo = "SN-5", Status = SerialStatus.Damaged, WarehouseId = Wh1 });
        await db.SaveChangesAsync();
        return db;
    }
    private static ErpDbContext CreateContext()
    {
        var options = new DbContextOptionsBuilder<ErpDbContext>()
            .UseInMemoryDatabase(Guid.NewGuid().ToString("N"), Root)
            .Options;
        var currentUser = new TestCurrentUser();
        return new ErpDbContext(options, currentUser, new CurrentBranchContext(currentUser));
    }
    // Pricing is never touched by the tracking check, so it is not wired.
    private static SalesDomainService CreateSalesDomain(ErpDbContext db) => new(
        new Repository<Customer>(db), new Repository<Warehouse>(db), new Repository<User>(db),
        new Repository<Item>(db), new Repository<TaxRate>(db), null!, new Repository<SalesConfig>(db),
        new Repository<Batch>(db), new Repository<Serial>(db), new Repository<StockLayer>(db),
        CreateSerialTracking(db));
    private static SerialTrackingService CreateSerialTracking(ErpDbContext db) => new(
        new Repository<Serial>(db), new Repository<SerialMovement>(db), new Repository<StockLayer>(db),
        new Repository<ProductConfig>(db), new TestCurrentUser());
    private static async Task SwitchSerialNumbersAsync(ErpDbContext db, bool enabled)
    {
        db.ProductConfig.Add(new ProductConfig { ConfigId = ProductConfig.SingletonId, SerialNumbersEnabled = enabled });
        await db.SaveChangesAsync();
    }
    // --- Product Configuration "Serial numbers" switch ---------------------------------------
    [Fact]
    public async Task SwitchOff_SerialItemSells_WithoutSerials()
    {
        await using var db = await SeedAsync();
        await SwitchSerialNumbersAsync(db, enabled: false);
        var sales = CreateSalesDomain(db);
        // No pre-tracking stock exists, yet nothing is asked: the item is plain stock now.
        var serials = await sales.ValidateLineTrackingAsync(SerialItemId, Wh1, 5, null, null, new HashSet<int>());
        Assert.Empty(serials);
    }
    [Fact]
    public async Task SwitchOff_SerialsSent_AreRefused()
    {
        await using var db = await SeedAsync();
        await SwitchSerialNumbersAsync(db, enabled: false);
        var sales = CreateSalesDomain(db);
        var tracking = CreateSerialTracking(db);
        var item = await db.Items.FirstAsync(i => i.ItemId == SerialItemId);
        var sale = await Assert.ThrowsAsync<DomainException>(() =>
            sales.ValidateLineTrackingAsync(SerialItemId, Wh1, 1, null, new[] { 1 }, new HashSet<int>()));
        var adjustment = await Assert.ThrowsAsync<DomainException>(() =>
            tracking.ResolveInboundAsync(item, Wh1, 1, new[] { "SN-X" }, new HashSet<string>()));
        Assert.Equal(ErrorCodes.ConfigDisabled, sale.Code);
        Assert.Equal(ErrorCodes.ConfigDisabled, adjustment.Code);
    }
    [Fact]
    public async Task SwitchOn_IsTheDefault_WhenConfigRowIsMissing()
    {
        await using var db = await SeedAsync();
        Assert.True(await CreateSerialTracking(db).IsEnabledAsync());
    }
 }
@@ -1,116 +0,0 @@
 using ERPCore.Domain.Entities;
 using ERPCore.Domain.Enums;
 using ERPCore.Dtos.Common;
 using ERPCore.Dtos.Notifications;
 using ERPCore.Dtos.Stock;
 using ERPCore.Infra.Persistence;
 using ERPCore.Repositories;
 using ERPCore.Services.Interfaces;
 using ERPCore.Services.Stock;
 using ERPCore.Tests.TestSupport;
 namespace ERPCore.Tests;
 /// <summary>Low-stock / reorder alerts raised after stock issues.</summary>
 public class LowStockAlertServiceTests
 {
    private const int ItemId = 1, WarehouseId = 1;
    [Theory]
    [InlineData(12, 4, 8, true)]    // 12 → 8 crosses the alert level of 10
    [InlineData(12, 2, 10, true)]   // landing exactly on the level counts
    [InlineData(20, 5, 15, false)]  // still above the level
    [InlineData(9, 3, 6, false)]    // was already low — no repeat alert on every sale
    public async Task Alerts_OnlyWhenAnIssueCrossesTheReorderPoint(decimal before, decimal issued, decimal after, bool alerts)
    {
        Assert.Equal(before - issued, after);
        await using var db = Seed();
        var tracker = new LowStockTracker();
        tracker.Track(ItemId, WarehouseId, issued);
        var notifications = new RecordingNotifications();
        await Service(db, tracker, after, notifications).CheckAsync();
        if (!alerts)
        {
            Assert.Empty(notifications.Raised);
            return;
        }
        var raised = Assert.Single(notifications.Raised);
        Assert.Equal(LowStockAlertService.ModuleKey, raised.ModuleKey);
        Assert.Contains("SKU-1", raised.Message);
        Assert.Contains($"down to {after:0.####} pcs at WH-1", raised.Message);
        Assert.Contains("Suggested reorder: 50 pcs", raised.Message);
    }
    [Fact]
    public async Task ItemsWithoutARule_OrUntouched_AreIgnored()
    {
        await using var db = Seed();
        var tracker = new LowStockTracker();
        tracker.Track(itemId: 99, WarehouseId, 100);     // no rule for this item
        var notifications = new RecordingNotifications();
        await Service(db, tracker, available: 0, notifications).CheckAsync();
        await Service(db, new LowStockTracker(), available: 0, notifications).CheckAsync();  // nothing issued
        Assert.Empty(notifications.Raised);
    }
    [Fact]
    public async Task Tracker_SumsIssuesWithinARequest_AndEmptiesWhenDrained()
    {
        var tracker = new LowStockTracker();
        tracker.Track(ItemId, WarehouseId, 3);
        tracker.Track(ItemId, WarehouseId, 4);
        tracker.Track(ItemId, WarehouseId, 0);
        Assert.Equal(7m, tracker.Drain()[(ItemId, WarehouseId)]);
        Assert.Empty(tracker.Drain());
    }
    private static LowStockAlertService Service(ErpDbContext db, LowStockTracker tracker, decimal available, INotificationService notifications)
        => new(tracker, new Repository<ItemReorder>(db), new FixedStock(available), notifications);
    private static ErpDbContext Seed()
    {
        var db = BankDepositTestSupport.CreateContext();   // users, branches, warehouses WH-1 / WH-2
        db.Uoms.Add(new Uom { UomId = 1, Name = "pcs" });
        db.Items.Add(new Item { ItemId = ItemId, Sku = "SKU-1", Name = "Cola 500ml", BaseUomId = 1, CategoryId = 1 });
        db.ItemReorders.Add(new ItemReorder { ReorderId = 1, ItemId = ItemId, WarehouseId = WarehouseId, ReorderPoint = 10, ReorderQty = 50 });
        db.SaveChanges();
        return db;
    }
    private sealed class FixedStock(decimal available) : IStockService
    {
        public Task<StockOnHandDto> GetOnHandAsync(int itemId, int warehouseId, CancellationToken ct = default)
            => Task.FromResult(new StockOnHandDto(itemId, warehouseId, available, available, 0, 0, 0, DateTime.UtcNow));
        public Task<PagedResponse<StockOnHandDto>> GetOnHandListAsync(int? itemId, int? warehouseId, int? branchId, PageQuery query, CancellationToken ct = default)
            => throw new NotSupportedException();
        public Task<IReadOnlyDictionary<int, decimal>> GetAvailableByItemAsync(int warehouseId, CancellationToken ct = default)
            => throw new NotSupportedException();
        public Task<PagedResponse<StockLedgerRowDto>> GetLedgerAsync(int? itemId, int? warehouseId, int? branchId, DateOnly? from, DateOnly? to,
            string? sourceDocType, int? sourceDocId, PageQuery query, CancellationToken ct = default) => throw new NotSupportedException();
        public Task<StockValuationDto> GetValuationAsync(int itemId, int warehouseId, CancellationToken ct = default)
            => throw new NotSupportedException();
    }
    private sealed class RecordingNotifications : INotificationService
    {
        public List<(string ModuleKey, string Title, string Message)> Raised { get; } = new();
        public Task RaiseAsync(string moduleKey, string title, string message, string? relatedEntityType = null,
            int? relatedEntityId = null, CancellationToken ct = default)
        {
            Raised.Add((moduleKey, title, message));
            return Task.CompletedTask;
        }
        public Task NotifyUsersAsync(IEnumerable<int> userIds, string moduleKey, string title, string message,
            string? relatedEntityType = null, int? relatedEntityId = null, CancellationToken ct = default) => throw new NotSupportedException();
        public Task<NotificationFeedDto> GetFeedAsync(int userId, int take = 20, CancellationToken ct = default) => throw new NotSupportedException();
        public Task MarkAllReadAsync(int userId, CancellationToken ct = default) => throw new NotSupportedException();
    }
 }
@@ -30,7 +30,7 @@ public class NotificationConfigServiceTests
        var result = await service.GetAsync();
-        Assert.Equal(1u, result.RowVersion);
+        Assert.Equal(7u, result.RowVersion);
        Assert.Contains(result.Value.Modules, m => m.ModuleKey == "sale.create" && m.EmailEnabled && !m.SmsEnabled && m.InAppEnabled);
        Assert.Contains(result.Value.Modules, m => m.ModuleKey == "grn.confirmed" && !m.EmailEnabled && !m.SmsEnabled && !m.InAppEnabled);
    }
@@ -55,9 +55,9 @@ public class NotificationConfigServiceTests
            }).ToList()
        };
-        var updated = await service.UpdateAsync(request, 1);
+        var updated = await service.UpdateAsync(request, 7);
-        Assert.Equal(2u, updated.RowVersion);
+        Assert.Equal(7u, updated.RowVersion);
        Assert.Contains(updated.Value.Modules, m => m.ModuleKey == catalog.GetAll()[0].Key && m.EmailEnabled && !m.SmsEnabled && !m.InAppEnabled);
        Assert.Contains(updated.Value.Modules, m => m.ModuleKey == catalog.GetAll()[1].Key && !m.EmailEnabled && m.SmsEnabled && m.InAppEnabled);
@@ -133,7 +133,7 @@ public class NotificationConfigServiceTests
            }).ToList()
        };
-        var ex = await Assert.ThrowsAsync<DomainException>(() => service.UpdateAsync(request, 1));
+        var ex = await Assert.ThrowsAsync<DomainException>(() => service.UpdateAsync(request, 7));
        Assert.Equal(ErrorCodes.ConcurrencyConflict, ex.Code);
        Assert.Equal(412, ex.StatusCode);
    }
@@ -1,124 +0,0 @@
 using ERPCore.Domain.Entities;
 using ERPCore.Domain.Enums;
 using ERPCore.Dtos.Production;
 using ERPCore.Infra.Auth;
 using ERPCore.Infra.Persistence;
 using ERPCore.Repositories;
 using ERPCore.Services.Production;
 using ERPCore.System.Errors;
 using ERPCore.Tests.TestSupport;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Storage;
 namespace ERPCore.Tests;
 /// <summary>
 /// Covers the 412 translation on the two production services, which save through
 /// <c>ExecuteInTransactionAsync</c> rather than a bare <c>SaveChangesAsync</c> and so guard
 /// concurrency differently from the inline pattern the other services use.
 /// </summary>
 public class ProductionConcurrencyTests
 {
    private static readonly InMemoryDatabaseRoot Root = new();
    [Fact]
    public async Task TemplateUpdateAsync_MapsConcurrencyFailuresToDomainException()
    {
        await using var db = CreateContext();
        // Validation runs before the transaction opens, so the referenced item has to exist.
        db.Items.Add(new Item
        {
            ItemId = 1,
            Sku = "FG-1",
            Name = "Finished good",
            CategoryId = 1,
            BaseUomId = 1,
            Status = EntityStatus.Active
        });
        await db.SaveChangesAsync();
        var service = CreateTemplateService(db);
        var ex = await Assert.ThrowsAsync<DomainException>(
            () => service.UpdateAsync(1, SingleStageTemplate(), expectedRowVersion: 1));
        Assert.Equal(ErrorCodes.ConcurrencyConflict, ex.Code);
        Assert.Equal(412, ex.StatusCode);
    }
    [Fact]
    public async Task RunUpdateStageQuantitiesAsync_MapsConcurrencyFailuresToDomainException()
    {
        await using var db = CreateContext();
        var service = CreateRunService(db);
        var ex = await Assert.ThrowsAsync<DomainException>(
            () => service.UpdateStageQuantitiesAsync(1, 1, new UpdateStageQuantitiesRequest()));
        Assert.Equal(ErrorCodes.ConcurrencyConflict, ex.Code);
        Assert.Equal(412, ex.StatusCode);
    }
    /// <summary>
    /// The smallest graph the validator accepts: one stage (both entry and terminal) with a
    /// stock input and a single item-bearing output, and no edges.
    /// </summary>
    private static SaveTemplateRequest SingleStageTemplate() => new()
    {
        Code = "TPL-1",
        Name = "Template 1",
        Stages =
        [
            new SaveStageRequest
            {
                Key = "tmp-1",
                Name = "Mix",
                Inputs =
                [
                    new SaveInputRequest
                    {
                        Source = StageInputSource.Stock,
                        ItemId = 1,
                        QtyUnit = StageQtyUnit.Pack,
                        QtyPerBatch = 1m
                    }
                ],
                Outputs =
                [
                    new SaveOutputRequest { Key = "tmp-o1", Name = "Output", ItemId = 1, QtyPerBatch = 1m }
                ]
            }
        ]
    };
    private static ErpDbContext CreateContext()
    {
        var options = new DbContextOptionsBuilder<ErpDbContext>()
            .UseInMemoryDatabase(Guid.NewGuid().ToString("N"), Root)
            .Options;
        // The real CurrentBranchContext over an unauthenticated user yields IsActive=false,
        // which leaves the branch query filters off: what a unit test wants.
        var currentUser = new TestCurrentUser();
        return new ErpDbContext(options, currentUser, new CurrentBranchContext(currentUser));
    }
    private static ProductionTemplateService CreateTemplateService(ErpDbContext db)
        => new(
            new Repository<ProductionTemplate>(db), new Repository<TemplateStage>(db),
            new Repository<StageInput>(db), new Repository<StageOutput>(db),
            new Repository<StageEdge>(db), new Repository<Item>(db),
            new Repository<Uom>(db), new Repository<ProductionRun>(db),
            new ThrowingTransactionUnitOfWork(), new TestCurrentUser());
    // The costing, measurement and numbering collaborators are only ever touched inside the
    // transaction lambda, which ThrowingTransactionUnitOfWork never invokes.
    private static ProductionRunService CreateRunService(ErpDbContext db)
        => new(
            new Repository<ProductionRun>(db), new Repository<ProductionTemplate>(db),
            new Repository<Warehouse>(db), new Repository<Bin>(db),
            new Repository<Item>(db), new Repository<ReasonCode>(db),
            fifo: null!, measure: null!, numbers: null!,
            new ThrowingTransactionUnitOfWork(), new TestCurrentUser());
 }
@@ -1,168 +0,0 @@
 using ERPCore.Common.Http;
 using ERPCore.Domain.Entities;
 using ERPCore.Domain.Enums;
 using ERPCore.Dtos.Config;
 using ERPCore.Infra.Auth;
 using ERPCore.Infra.Gl;
 using ERPCore.Infra.Persistence;
 using ERPCore.Infra.UoW;
 using ERPCore.Repositories;
 using ERPCore.Services;
 using ERPCore.Services.Gl;
 using ERPCore.Services.Interfaces;
 using ERPCore.System.Errors;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Storage;
 using Microsoft.Extensions.Configuration;
 namespace ERPCore.Tests.TestSupport;
 /// <summary>Records every journal it is asked to post; can be told to reject them instead.</summary>
 internal sealed class FakeGeneralLedger : IGeneralLedgerService
 {
    public const long CashAccountId = 1, BankAccountId = 2, OtherBankAccountId = 3;
    public List<GlJournalEntryRequest> Posted { get; } = new();
    public bool Reject { get; set; }
    public IReadOnlyList<GlBankAccount> Accounts { get; init; } =
    [
        new("Cash", CashAccountId, "Main Till", null, "Petty", null, 101, "1000-01", "LKR"),
        new("Bank", BankAccountId, "BOC Current", "Bank of Ceylon", null, "0001234567", 102, "1010-01", "LKR"),
        new("Bank", OtherBankAccountId, "HNB Savings", "Hatton National Bank", null, "9876543210", 103, "1010-02", "LKR")
    ];
    public Task<GeneralLedgerResponse> ForwardAsync(HttpMethod method, string path, string? queryString, string? contentType, Stream? body, CancellationToken ct)
        => throw new NotSupportedException();
    public Task<GlJournalEntryResult> PostJournalEntryAsync(GlJournalEntryRequest request, CancellationToken ct)
    {
        if (Reject) throw new DomainException(ErrorCodes.Validation, "GL rejected the entry.", 502);
        Posted.Add(request);
        return Task.FromResult(new GlJournalEntryResult($"JE-{Posted.Count}", true));
    }
    public Task<GlPeriod> GetPeriodByDateAsync(DateOnly date, CancellationToken ct) => Task.FromResult(new GlPeriod(1, 1));
    public Task<IReadOnlyList<GlBankAccount>> ListBankAccountsAsync(CancellationToken ct) => Task.FromResult(Accounts);
 }
 /// <summary>The in-memory provider has no transactions: run the work, then save — what the real one commits.</summary>
 internal sealed class PassThroughUnitOfWork(ErpDbContext db) : IUnitOfWork
 {
    public Task<int> SaveChangesAsync(CancellationToken ct = default) => db.SaveChangesAsync(ct);
    public async Task ExecuteInTransactionAsync(Func<CancellationToken, Task> action, CancellationToken ct = default)
    {
        await action(ct);
        await db.SaveChangesAsync(ct);
    }
    public async Task<T> ExecuteInTransactionAsync<T>(Func<CancellationToken, Task<T>> action, CancellationToken ct = default)
    {
        var result = await action(ct);
        await db.SaveChangesAsync(ct);
        return result;
    }
 }
 internal sealed class FakeNumberSequence : INumberSequenceService
 {
    private int _next;
    public Task<string> NextAsync(string docType, int branchId, CancellationToken ct = default) => Task.FromResult($"{docType}-{++_next:00000}");
    public Task<string> NextAsync(string docType, CancellationToken ct = default) => Task.FromResult($"{docType}-{++_next:00000}");
 }
 /// <summary>Branching on: the requested branch is used as-is.</summary>
 internal sealed class FakeBranchConfig : IBranchConfigService
 {
    public Task<ETagged<BranchConfigDto>> GetAsync(CancellationToken ct = default) => throw new NotSupportedException();
    public Task<ETagged<BranchConfigDto>> UpdateAsync(UpdateBranchConfigRequest request, uint expectedRowVersion, CancellationToken ct = default)
        => throw new NotSupportedException();
    public Task<bool> IsBranchingEnabledAsync(CancellationToken ct = default) => Task.FromResult(true);
    public Task<int> ResolveBranchIdAsync(int requestedBranchId, CancellationToken ct = default)
        => requestedBranchId > 0 ? Task.FromResult(requestedBranchId) : throw new DomainException(ErrorCodes.Validation, "Branch is required.", 422);
    public Task<bool> IsWarehouseBranchingEnabledAsync(CancellationToken ct = default) => Task.FromResult(true);
    public Task<int> ResolveWarehouseBranchIdAsync(int requestedBranchId, CancellationToken ct = default) => Task.FromResult(requestedBranchId);
    public Task<int> ResolveDefaultBranchIdAsync(CancellationToken ct = default) => Task.FromResult(1);
 }
 /// <summary>Seeds and services for the cash-in-hand / bank-deposit tests. Two branches, one warehouse each.</summary>
 internal static class BankDepositTestSupport
 {
    private static readonly InMemoryDatabaseRoot Root = new();
    public const int Branch1 = 1, Branch2 = 2;
    public const int Warehouse1 = 1, Warehouse2 = 2;
    public static BusinessDayClock Clock { get; } = new(Config());
    public static IConfiguration Config(DateOnly? trackingStart = null) => new ConfigurationBuilder()
        .AddInMemoryCollection(new Dictionary<string, string?>
        {
            ["DayEndReport:TimeZone"] = "Asia/Colombo",
            ["BankDeposit:DefaultCashAccountCode"] = "1000-01",
            ["BankDeposit:CashTrackingStartDate"] = trackingStart?.ToString("yyyy-MM-dd")
        })
        .Build();
    /// <summary>Midday on a local business day, as the UTC instant documents are stamped with.</summary>
    public static DateTime At(DateOnly day) => Clock.ToUtc(day).AddHours(6);
    public static ErpDbContext CreateContext()
    {
        var options = new DbContextOptionsBuilder<ErpDbContext>()
            .UseInMemoryDatabase(Guid.NewGuid().ToString("N"), Root)
            .Options;
        var currentUser = new TestCurrentUser();
        var db = new ErpDbContext(options, currentUser, new CurrentBranchContext(currentUser));
        db.Users.Add(new User { UserId = User.SystemUserId, Username = "system", DisplayName = "System" });
        db.Branches.AddRange(
            new Branch { BranchId = Branch1, Code = "BR-001", Name = "Colombo" },
            new Branch { BranchId = Branch2, Code = "BR-002", Name = "Kandy" });
        db.Warehouses.AddRange(
            new Warehouse { WarehouseId = Warehouse1, Code = "WH-1", Name = "Colombo Store", BranchId = Branch1 },
            new Warehouse { WarehouseId = Warehouse2, Code = "WH-2", Name = "Kandy Store", BranchId = Branch2 });
        db.SaveChanges();
        return db;
    }
    private static int _id;
    public static SalesSlip CashSlip(DateOnly day, decimal cash, decimal card = 0m, int warehouseId = Warehouse1)
    {
        var id = Interlocked.Increment(ref _id);
        return new SalesSlip
        {
            SalesSlipId = id, SlipNo = $"SL-{id}", SlipDate = At(day), Status = SalesSlipStatus.Posted, WarehouseId = warehouseId,
            GrandTotal = cash + card, PaidAmount = cash + card, CashAmount = cash, CardAmount = card
        };
    }
    public static CashInHandService CashService(ErpDbContext db, DateOnly? trackingStart)
        => new(new Repository<SalesSlip>(db), new Repository<BundleSale>(db), new Repository<SalesInvoicePayment>(db),
            new Repository<ExpensePayment>(db), new Repository<BankDeposit>(db),
            new CurrentBranchContext(new TestCurrentUser()), Clock, Config(trackingStart));
    public static BankDepositService DepositService(ErpDbContext db, DateOnly? trackingStart, FakeGeneralLedger gl)
    {
        var currentUser = new TestCurrentUser();
        return new BankDepositService(
            new Repository<BankDeposit>(db), new Repository<Branch>(db), CashService(db, trackingStart), gl,
            currentUser, new CurrentBranchContext(currentUser), new FakeNumberSequence(), new FakeBranchConfig(),
            new PassThroughUnitOfWork(db), db, Clock);
    }
    public static BankDeposit Deposit(DateOnly businessDate, decimal amount, int branchId = Branch1,
        BankDepositStatus status = BankDepositStatus.Posted)
    {
        var id = Interlocked.Increment(ref _id);
        return new BankDeposit
        {
            BankDepositId = id, DocNo = $"BD-{id}", BranchId = branchId, BusinessDate = businessDate, DepositDate = businessDate,
            Amount = amount, Status = status, FromCashAccountCode = "1000-01", FromCashAccountName = "Main Till",
            ToBankAccountCode = "1010-01", ToBankAccountName = "BOC Current", CreatedBy = User.SystemUserId
        };
    }
 }
@@ -1,66 +0,0 @@
 using ERPCore.Infra.Gl;
 using ERPCore.Services.Gl;
 using ERPCore.Services.Interfaces;
 using ERPCore.System.Errors;
 namespace ERPCore.Tests.TestSupport;
 /// <summary>
 /// Stands in for the external GL service. Only <see cref="ListAccountsAsync"/> is implemented —
 /// nothing under test here posts a journal, and leaving the rest throwing means a test that starts
 /// doing so fails loudly rather than against a silently empty fake.
 /// </summary>
 internal sealed class StubGeneralLedgerService : IGeneralLedgerService
 {
    private readonly IReadOnlyList<GlAccount> _accounts;
    private readonly Exception? _throws;
    public StubGeneralLedgerService(IReadOnlyList<GlAccount> accounts) => _accounts = accounts;
    public StubGeneralLedgerService(Exception throws) { _accounts = []; _throws = throws; }
    public int Calls { get; private set; }
    /// <summary>A postable, active account — the ordinary case.</summary>
    public static GlAccount Postable(string code, string name = "Account", short type = 1) => new(code, name, type, true, true);
    /// <summary>A header/control account. GL rejects journal lines against these.</summary>
    public static GlAccount NotPostable(string code, string name = "Header", short type = 1) => new(code, name, type, false, true);
    public Task<IReadOnlyList<GlAccount>> ListAccountsAsync(CancellationToken ct)
    {
        Calls++;
        return _throws is not null
            ? Task.FromException<IReadOnlyList<GlAccount>>(_throws)
            : Task.FromResult(_accounts);
    }
    public Task<GeneralLedgerResponse> ForwardAsync(
        HttpMethod method, string path, string? queryString, string? contentType, Stream? body, CancellationToken ct)
        => throw new NotSupportedException();
    public Task<GlJournalEntryResult> PostJournalEntryAsync(GlJournalEntryRequest request, CancellationToken ct)
        => throw new NotSupportedException();
    public Task<GlPeriod> GetPeriodByDateAsync(DateOnly date, CancellationToken ct)
        => throw new NotSupportedException();
    public Task<IReadOnlyList<GlBankAccount>> ListBankAccountsAsync(CancellationToken ct)
        => throw new NotSupportedException();
    public static DomainException Unreachable() =>
        new(ErrorCodes.GlServiceUnavailable, "The General Ledger service is unreachable.", 503);
 }
 /// <summary>Returns a fixed mapping, for exercising the startup validator without a database.</summary>
 internal sealed class StubGlAccountConfigService(params (GlAccountRole Role, string? Code)[] mappings) : IGlAccountConfigService
 {
    public Task<GlAccountCodes> GetCodesAsync(CancellationToken ct = default) =>
        Task.FromResult(new GlAccountCodes(mappings.ToDictionary(m => m.Role, m => m.Code)));
    public Task<ERPCore.Common.Http.ETagged<ERPCore.Dtos.Config.GlAccountConfigDto>> GetAsync(CancellationToken ct = default)
        => throw new NotSupportedException();
    public Task<ERPCore.Common.Http.ETagged<ERPCore.Dtos.Config.GlAccountConfigDto>> UpdateAsync(
        ERPCore.Dtos.Config.UpdateGlAccountConfigRequest request, uint expectedRowVersion, CancellationToken ct = default)
        => throw new NotSupportedException();
 }
@@ -11,12 +11,6 @@ internal sealed class TestCurrentUser : ICurrentUser
    public string UserId => "system";
    public int AuditUserId => User.SystemUserId;
    public bool IsAuthenticated => false;
    // Unauthenticated, so no role claim and no branch scoping: the three members the
    // AuthHex integration added to ICurrentUser.
    public string? RoleCode => null;
    public bool IsAdmin => false;
    public int? BranchId => null;
 }
 internal sealed class ThrowingUnitOfWork : ERPCore.Infra.UoW.IUnitOfWork
@@ -31,25 +25,6 @@ internal sealed class ThrowingUnitOfWork : ERPCore.Infra.UoW.IUnitOfWork
        => throw new NotSupportedException();
 }
 /// <summary>
 /// Fails the transactional path the way a lost optimistic-concurrency race does, so the
 /// services that save through <c>ExecuteInTransactionAsync</c> can be covered too. The
 /// lambda is never invoked, which is the point: the real <c>UnitOfWork</c> issues its own
 /// <c>SaveChangesAsync</c> after the lambda returns, so the catch under test has to sit
 /// outside it.
 /// </summary>
 internal sealed class ThrowingTransactionUnitOfWork : ERPCore.Infra.UoW.IUnitOfWork
 {
    public Task<int> SaveChangesAsync(CancellationToken ct = default)
        => throw new DbUpdateConcurrencyException("Test concurrency conflict.");
    public Task ExecuteInTransactionAsync(Func<CancellationToken, Task> action, CancellationToken ct = default)
        => throw new DbUpdateConcurrencyException("Test concurrency conflict.");
    public Task<T> ExecuteInTransactionAsync<T>(Func<CancellationToken, Task<T>> action, CancellationToken ct = default)
        => throw new DbUpdateConcurrencyException("Test concurrency conflict.");
 }
 internal static class NotificationConfigTestSupport
 {
    private static readonly InMemoryDatabaseRoot Root = new();
@@ -60,10 +35,7 @@ internal static class NotificationConfigTestSupport
            .UseInMemoryDatabase(name, Root)
            .Options;
-        // The real CurrentBranchContext over an unauthenticated user yields IsActive=false,
+        return new ErpDbContext(options, new TestCurrentUser());
        // which leaves the branch query filters off: what a unit test wants.
        var currentUser = new TestCurrentUser();
        return new ErpDbContext(options, currentUser, new CurrentBranchContext(currentUser));
    }
    public static async Task SeedAsync(ErpDbContext db, IEnumerable<NotificationConfigModule>? modules = null)
@@ -80,8 +52,7 @@ internal static class NotificationConfigTestSupport
            NotificationConfigId = NotificationConfig.SingletonId,
            UpdatedBy = User.SystemUserId,
            UpdatedAt = DateTime.UtcNow,
-            // No RowVersion here on purpose: ErpDbContext.BumpRowVersions stamps every
+            RowVersion = 7,
            // inserted row with 1, so any seeded value is overwritten on save.
        };
        if (modules is not null)
@@ -1,43 +0,0 @@
 using Microsoft.AspNetCore.Authorization;
 using ERPCore.Dtos.Approvals;
 using ERPCore.Infra.Auth;
 using ERPCore.Services;
 using ERPCore.Services.Interfaces;
 using Microsoft.AspNetCore.Mvc;
 namespace ERPCore.Controllers;
 /// <summary>
 /// Approvals inbox and settings (docs/DUAL_APPROVAL_PLAN.md §7, §10). The inbox is open to every
 /// signed-in user — it only lists what they may approve and their own requests. Reading the
 /// settings is open too (screens need to know whether prices are locked); changing them needs
 /// <c>settings.approvals</c>.
 /// </summary>
 [Route("api/v1/approvals")]
 public sealed class ApprovalsController : ApiControllerBase
 {
    private readonly ApprovalInboxService _inbox;
    private readonly IApprovalService _approvals;
    public ApprovalsController(ApprovalInboxService inbox, IApprovalService approvals)
    {
        _inbox = inbox;
        _approvals = approvals;
    }
    [HttpGet("pending")]
    [ProducesResponseType(typeof(PendingApprovalsDto), StatusCodes.Status200OK)]
    public async Task<ActionResult<PendingApprovalsDto>> Pending(CancellationToken ct)
        => Ok(await _inbox.PendingAsync(ct));
    [HttpGet("config")]
    [ProducesResponseType(typeof(ApprovalConfigDto), StatusCodes.Status200OK)]
    public async Task<ActionResult<ApprovalConfigDto>> GetConfig(CancellationToken ct)
        => Ok(await _approvals.GetConfigAsync(ct));
    [HttpPut("config")]
    [Authorize(Policy = NavPolicies.Prefix + "settings.approvals")]
    [ProducesResponseType(typeof(ApprovalConfigDto), StatusCodes.Status200OK)]
    public async Task<ActionResult<ApprovalConfigDto>> UpdateConfig([FromBody] UpdateApprovalConfigRequest request, CancellationToken ct)
        => Ok(await _approvals.UpdateConfigAsync(request, ct));
 }
@@ -28,14 +28,20 @@ public sealed class AuthController : ControllerBase
    private readonly IAuthAltService _alt;
    private readonly IRoleService _roles;
    private readonly IAuditService _audit;
    private readonly IUserManagementService _userManagement;
    private readonly ICurrentUser _currentUser;
-    public AuthController(IAuthUserService users, IAuthRecoveryService recovery, IAuthAltService alt, IRoleService roles, IAuditService audit)
+    public AuthController(
        IAuthUserService users, IAuthRecoveryService recovery, IAuthAltService alt, IRoleService roles, IAuditService audit,
        IUserManagementService userManagement, ICurrentUser currentUser)
    {
        _users = users;
        _recovery = recovery;
        _alt = alt;
        _roles = roles;
        _audit = audit;
        _userManagement = userManagement;
        _currentUser = currentUser;
    }
    /// <summary>
@@ -139,6 +145,8 @@ public sealed class AuthController : ControllerBase
    public async Task<IActionResult> ChangePassword([FromBody] ChangeUserPasswordRequest request, CancellationToken ct)
    {
        await _users.ChangeUserPasswordAsync(request, RequireBearerToken(), ct);
        // AuthHex accepted the new password — release the first-login forced change.
        await _userManagement.ClearMustChangePasswordAsync(_currentUser.AuditUserId, ct);
        AuthCookieWriter.ClearSession(Response);
        return NoContent();
    }
@@ -1,78 +0,0 @@
 using Microsoft.AspNetCore.Authorization;
 using ERPCore.Domain.Enums;
 using ERPCore.Dtos.Accounts;
 using ERPCore.Dtos.Common;
 using ERPCore.Infra.Auth;
 using ERPCore.Services.Interfaces;
 using Microsoft.AspNetCore.Mvc;
 namespace ERPCore.Controllers;
 /// <summary>
 /// Till cash deposited to the bank, and the cash in hand behind it (docs/BANK_DEPOSIT_MODULE_PLAN.md §7.3).
 /// Recording needs the Create action on <c>accounts.bank-deposits</c>; cancelling needs Delete.
 /// </summary>
 [Route("api/v1/bank-deposits")]
 [Authorize(Policy = NavPolicies.Prefix + "accounts.bank-deposits")]
 public sealed class BankDepositsController : ApiControllerBase
 {
    private readonly IBankDepositService _deposits;
    private readonly ICashInHandService _cash;
    public BankDepositsController(IBankDepositService deposits, ICashInHandService cash)
    {
        _deposits = deposits;
        _cash = cash;
    }
    /// <summary>Deposits filtered by business date range, branch, bank account and status, plus their total.</summary>
    [HttpGet]
    [ProducesResponseType(typeof(BankDepositListDto), StatusCodes.Status200OK)]
    public async Task<ActionResult<BankDepositListDto>> List(
        [FromQuery] PageQuery query, [FromQuery] DateOnly? from, [FromQuery] DateOnly? to, [FromQuery] int? branchId,
        [FromQuery] long? bankAccountId, [FromQuery] BankDepositStatus? status, CancellationToken ct)
        => Ok(await _deposits.ListAsync(query, new BankDepositListFilter(from, to, branchId, bankAccountId, status), ct));
    [HttpGet("{bankDepositId:int}")]
    [ProducesResponseType(typeof(BankDepositDto), StatusCodes.Status200OK)]
    [ProducesResponseType(StatusCodes.Status404NotFound)]
    public async Task<ActionResult<BankDepositDto>> GetById(int bankDepositId, CancellationToken ct)
    {
        var result = await _deposits.GetAsync(bankDepositId, ct);
        return result is null ? NotFound() : Ok(result);
    }
    /// <summary>One business day's cash position (defaults to today) and how much of it can still be deposited.</summary>
    [HttpGet("cash-in-hand")]
    [ProducesResponseType(typeof(CashInHandDto), StatusCodes.Status200OK)]
    public async Task<ActionResult<CashInHandDto>> CashInHand([FromQuery] DateOnly? date, [FromQuery] int? branchId, CancellationToken ct)
        => Ok(await _cash.GetPositionAsync(date, branchId, ct));
    /// <summary>Day-wise cash position for <c>from</c>..<c>to</c> inclusive (at most 92 days).</summary>
    [HttpGet("cash-in-hand/daily")]
    [ProducesResponseType(typeof(CashInHandDailyDto), StatusCodes.Status200OK)]
    [ProducesResponseType(StatusCodes.Status400BadRequest)]
    public async Task<ActionResult<CashInHandDailyDto>> CashInHandDaily(
        [FromQuery] DateOnly from, [FromQuery] DateOnly to, [FromQuery] int? branchId, CancellationToken ct)
        => Ok(await _cash.GetDailyAsync(from, to, branchId, ct));
    /// <summary>Record a deposit; posts GL (Debit bank / Credit cash). Rejected above the cash in hand.</summary>
    [HttpPost]
    [Authorize(Policy = NavPolicies.Prefix + "accounts.bank-deposits" + NavPolicies.ActionSeparator + NavPolicies.CreateAction)]
    [ProducesResponseType(typeof(BankDepositDto), StatusCodes.Status201Created)]
    [ProducesResponseType(StatusCodes.Status400BadRequest)]
    public async Task<ActionResult<BankDepositDto>> Create([FromBody] CreateBankDepositRequest request, CancellationToken ct)
    {
        var result = await _deposits.CreateAsync(request, ct);
        return Created($"/api/v1/bank-deposits/{result.BankDepositId}", result);
    }
    /// <summary>Cancel a Posted deposit; posts the reversing GL entry and puts the cash back in hand.</summary>
    [HttpPost("{bankDepositId:int}/cancel")]
    [Authorize(Policy = NavPolicies.Prefix + "accounts.bank-deposits" + NavPolicies.ActionSeparator + NavPolicies.DeleteAction)]
    [ProducesResponseType(typeof(BankDepositDto), StatusCodes.Status200OK)]
    [ProducesResponseType(StatusCodes.Status404NotFound)]
    [ProducesResponseType(StatusCodes.Status409Conflict)]
    public async Task<ActionResult<BankDepositDto>> Cancel(int bankDepositId, [FromBody] CancelBankDepositRequest request, CancellationToken ct)
        => Ok(await _deposits.CancelAsync(bankDepositId, request, ct));
 }
@@ -23,10 +23,8 @@ public sealed class CustomersController : ApiControllerBase
        [FromQuery] PageQuery query,
        [FromQuery] EntityStatus? status,
        [FromQuery] CustomerType? customerType,
-        CancellationToken ct,
+        CancellationToken ct)
-        [FromQuery] bool includeCashCustomer = false,
+        => Ok(await _customers.ListAsync(query, status, customerType, ct));
        [FromQuery] int? branchId = null)
        => Ok(await _customers.ListAsync(query, status, customerType, includeCashCustomer, branchId, ct));
    [HttpGet("{customerId:int}")]
    [ProducesResponseType(typeof(CustomerDto), StatusCodes.Status200OK)]
@@ -1,31 +0,0 @@
 using Microsoft.AspNetCore.Authorization;
 using ERPCore.Dtos.Reports;
 using ERPCore.Infra.Auth;
 using ERPCore.Services.Interfaces;
 using Microsoft.AspNetCore.Mvc;
 namespace ERPCore.Controllers;
 /// <summary>Day-End Sales Report — a day's sales, payments by method, expenses and income, and the
 /// same day-wise over a range for the income chart/PDF (docs/DAY_END_SALES_REPORT_PLAN.md §4).</summary>
 [Route("api/v1/day-end-report")]
 [Authorize(Policy = NavPolicies.Prefix + "sales.day-end-report")]
 public sealed class DayEndReportController : ApiControllerBase
 {
    private readonly IDayEndReportService _reports;
    public DayEndReportController(IDayEndReportService reports) => _reports = reports;
    /// <summary>One business day (defaults to today in the report's time zone).</summary>
    [HttpGet]
    [ProducesResponseType(typeof(DayEndReportDto), StatusCodes.Status200OK)]
    public async Task<ActionResult<DayEndReportDto>> GetDay([FromQuery] DateOnly? date, [FromQuery] int? branchId, CancellationToken ct)
        => Ok(await _reports.GetDayAsync(date, branchId, ct));
    /// <summary>Day-wise figures for <c>from</c>..<c>to</c> inclusive (at most 92 days).</summary>
    [HttpGet("daily")]
    [ProducesResponseType(typeof(DayEndDailyReportDto), StatusCodes.Status200OK)]
    [ProducesResponseType(StatusCodes.Status400BadRequest)]
    public async Task<ActionResult<DayEndDailyReportDto>> GetDaily([FromQuery] DateOnly from, [FromQuery] DateOnly to, [FromQuery] int? branchId, CancellationToken ct)
        => Ok(await _reports.GetDailyAsync(from, to, branchId, ct));
 }
@@ -1,57 +0,0 @@
 using Microsoft.AspNetCore.Authorization;
 using ERPCore.Dtos.Expenses;
 using ERPCore.Infra.Auth;
 using ERPCore.Services.Interfaces;
 using Microsoft.AspNetCore.Mvc;
 namespace ERPCore.Controllers;
 /// <summary>
 /// Expense categories and titles (docs/EXPENSE_MODULE_PLAN.md §6 "Setup"). Reading is open to
 /// anyone with Accounts access (the expense form needs the lists); changes need the
 /// Expense Setup permission. Categories are the fixed seeded four — there is no create
 /// endpoint; only their active flag can change. Titles can be added under them.
 /// </summary>
 [Route("api/v1")]
 [Authorize(Policy = NavPolicies.Prefix + "accounts")]
 public sealed class ExpenseSetupController : ApiControllerBase
 {
    private const string SetupPolicy = NavPolicies.Prefix + "accounts.expense-setup";
    private readonly IExpenseSetupService _setup;
    public ExpenseSetupController(IExpenseSetupService setup) => _setup = setup;
    /// <summary>Categories, each with its titles, in display order.</summary>
    [HttpGet("expense-categories")]
    [ProducesResponseType(typeof(IReadOnlyList<ExpenseCategoryDto>), StatusCodes.Status200OK)]
    public async Task<ActionResult<IReadOnlyList<ExpenseCategoryDto>>> List([FromQuery] bool includeInactive, CancellationToken ct)
        => Ok(await _setup.ListAsync(includeInactive, ct));
    [HttpPut("expense-categories/{expenseCategoryId:int}")]
    [Authorize(Policy = SetupPolicy)]
    [ProducesResponseType(typeof(ExpenseCategoryDto), StatusCodes.Status200OK)]
    [ProducesResponseType(StatusCodes.Status404NotFound)]
    [ProducesResponseType(StatusCodes.Status409Conflict)]
    public async Task<ActionResult<ExpenseCategoryDto>> UpdateCategory(int expenseCategoryId, [FromBody] UpdateExpenseCategoryRequest request, CancellationToken ct)
        => Ok(await _setup.UpdateCategoryAsync(expenseCategoryId, request, ct));
    [HttpPost("expense-categories/{expenseCategoryId:int}/titles")]
    [Authorize(Policy = SetupPolicy)]
    [ProducesResponseType(typeof(ExpenseTitleDto), StatusCodes.Status201Created)]
    [ProducesResponseType(StatusCodes.Status404NotFound)]
    [ProducesResponseType(StatusCodes.Status409Conflict)]
    public async Task<ActionResult<ExpenseTitleDto>> CreateTitle(int expenseCategoryId, [FromBody] CreateExpenseTitleRequest request, CancellationToken ct)
    {
        var dto = await _setup.CreateTitleAsync(expenseCategoryId, request, ct);
        return Created($"/api/v1/expense-titles/{dto.ExpenseTitleId}", dto);
    }
    [HttpPut("expense-titles/{expenseTitleId:int}")]
    [Authorize(Policy = SetupPolicy)]
    [ProducesResponseType(typeof(ExpenseTitleDto), StatusCodes.Status200OK)]
    [ProducesResponseType(StatusCodes.Status404NotFound)]
    [ProducesResponseType(StatusCodes.Status409Conflict)]
    public async Task<ActionResult<ExpenseTitleDto>> UpdateTitle(int expenseTitleId, [FromBody] UpdateExpenseTitleRequest request, CancellationToken ct)
        => Ok(await _setup.UpdateTitleAsync(expenseTitleId, request, ct));
 }
@@ -1,127 +0,0 @@
 using Microsoft.AspNetCore.Authorization;
 using ERPCore.Domain.Enums;
 using ERPCore.Dtos.Common;
 using ERPCore.Dtos.Expenses;
 using ERPCore.Infra.Auth;
 using ERPCore.Services.Interfaces;
 using Microsoft.AspNetCore.Mvc;
 namespace ERPCore.Controllers;
 /// <summary>Business expense bills — draft, post (GL accrual), pay, cancel (docs/EXPENSE_MODULE_PLAN.md §6).</summary>
 [Route("api/v1/expenses")]
 [Authorize(Policy = NavPolicies.Prefix + "accounts.expenses")]
 public sealed class ExpensesController : ApiControllerBase
 {
    private readonly IExpenseService _expenses;
    private readonly IExpensePaymentService _payments;
    public ExpensesController(IExpenseService expenses, IExpensePaymentService payments)
    {
        _expenses = expenses;
        _payments = payments;
    }
    [HttpGet]
    [ProducesResponseType(typeof(PagedResponse<ExpenseSummaryDto>), StatusCodes.Status200OK)]
    public async Task<ActionResult<PagedResponse<ExpenseSummaryDto>>> List(
        [FromQuery] PageQuery query, [FromQuery] ExpenseStatus? status, [FromQuery] ExpensePaymentStatus? paymentStatus,
        [FromQuery] int? categoryId, [FromQuery] int? titleId, [FromQuery] DateOnly? from, [FromQuery] DateOnly? to,
        [FromQuery] bool overdueOnly, CancellationToken ct)
        => Ok(await _expenses.ListAsync(query, new ExpenseListFilter(status, paymentStatus, categoryId, titleId, from, to, overdueOnly), ct));
    /// <summary>Totals by category → title for Posted expenses dated in [from, to] (default: this month), plus unpaid/overdue position.</summary>
    [HttpGet("summary")]
    [ProducesResponseType(typeof(ExpenseSummaryReportDto), StatusCodes.Status200OK)]
    public async Task<ActionResult<ExpenseSummaryReportDto>> Summary([FromQuery] DateOnly? from, [FromQuery] DateOnly? to, CancellationToken ct)
        => Ok(await _expenses.GetSummaryAsync(from, to, ct));
    [HttpGet("{expenseId:int}")]
    [ProducesResponseType(typeof(ExpenseDto), StatusCodes.Status200OK)]
    [ProducesResponseType(StatusCodes.Status404NotFound)]
    public async Task<ActionResult<ExpenseDto>> GetById(int expenseId, CancellationToken ct)
    {
        var result = await _expenses.GetAsync(expenseId, ct);
        if (result is null) return NotFound();
        SetETag(result.RowVersion);
        return Ok(result.Value);
    }
    [HttpPost]
    [ProducesResponseType(typeof(ExpenseDto), StatusCodes.Status201Created)]
    [ProducesResponseType(StatusCodes.Status422UnprocessableEntity)]
    public async Task<ActionResult<ExpenseDto>> Create([FromBody] CreateExpenseRequest request, CancellationToken ct)
    {
        var result = await _expenses.CreateAsync(request, ct);
        SetETag(result.RowVersion);
        return Created($"/api/v1/expenses/{result.Value.ExpenseId}", result.Value);
    }
    [HttpPut("{expenseId:int}")]
    [ProducesResponseType(typeof(ExpenseDto), StatusCodes.Status200OK)]
    [ProducesResponseType(StatusCodes.Status404NotFound)]
    [ProducesResponseType(StatusCodes.Status409Conflict)]
    [ProducesResponseType(StatusCodes.Status412PreconditionFailed)]
    public async Task<ActionResult<ExpenseDto>> Update(int expenseId, [FromBody] UpdateExpenseRequest request, CancellationToken ct)
    {
        var expected = RequireIfMatch();
        var result = await _expenses.UpdateAsync(expenseId, request, expected, ct);
        SetETag(result.RowVersion);
        return Ok(result.Value);
    }
    /// <summary>Draft only.</summary>
    [HttpDelete("{expenseId:int}")]
    [ProducesResponseType(StatusCodes.Status204NoContent)]
    [ProducesResponseType(StatusCodes.Status404NotFound)]
    [ProducesResponseType(StatusCodes.Status409Conflict)]
    public async Task<IActionResult> Delete(int expenseId, CancellationToken ct)
    {
        await _expenses.DeleteAsync(expenseId, ct);
        return NoContent();
    }
    /// <summary>Accrue the expense to GL (Debit expense account / Credit Accrued Expenses).</summary>
    [HttpPost("{expenseId:int}/post")]
    [ProducesResponseType(typeof(ExpenseDto), StatusCodes.Status200OK)]
    [ProducesResponseType(StatusCodes.Status404NotFound)]
    [ProducesResponseType(StatusCodes.Status409Conflict)]
    public async Task<ActionResult<ExpenseDto>> Post(int expenseId, CancellationToken ct)
        => Ok(await _expenses.PostAsync(expenseId, ct));
    /// <summary>Post a Draft and pay it, in full or partially, in one transaction; any remainder stays as the balance.</summary>
    [HttpPost("{expenseId:int}/post-and-pay")]
    [ProducesResponseType(typeof(ExpenseDto), StatusCodes.Status200OK)]
    [ProducesResponseType(StatusCodes.Status400BadRequest)]
    [ProducesResponseType(StatusCodes.Status404NotFound)]
    [ProducesResponseType(StatusCodes.Status409Conflict)]
    public async Task<ActionResult<ExpenseDto>> PostAndPay(int expenseId, [FromBody] CreateExpensePaymentRequest request, CancellationToken ct)
        => Ok(await _payments.PostAndPayAsync(expenseId, request, ct));
    /// <summary>Draft, or Posted with no payments (posts the reversing GL entry).</summary>
    [HttpPost("{expenseId:int}/cancel")]
    [ProducesResponseType(typeof(ExpenseDto), StatusCodes.Status200OK)]
    [ProducesResponseType(StatusCodes.Status404NotFound)]
    [ProducesResponseType(StatusCodes.Status409Conflict)]
    public async Task<ActionResult<ExpenseDto>> Cancel(int expenseId, [FromBody] CancelExpenseRequest request, CancellationToken ct)
        => Ok(await _expenses.CancelAsync(expenseId, request, ct));
    /// <summary>Pay against the balance, in full or in installments; one GL entry per submission.</summary>
    [HttpPost("{expenseId:int}/payments")]
    [ProducesResponseType(typeof(IReadOnlyList<ExpensePaymentDto>), StatusCodes.Status201Created)]
    [ProducesResponseType(StatusCodes.Status400BadRequest)]
    [ProducesResponseType(StatusCodes.Status404NotFound)]
    [ProducesResponseType(StatusCodes.Status409Conflict)]
    public async Task<ActionResult<IReadOnlyList<ExpensePaymentDto>>> Pay(int expenseId, [FromBody] CreateExpensePaymentRequest request, CancellationToken ct)
    {
        var rows = await _payments.PayAsync(expenseId, request, ct);
        return Created($"/api/v1/expenses/{expenseId}/payments", rows);
    }
    /// <summary>Payment history, newest first.</summary>
    [HttpGet("{expenseId:int}/payments")]
    [ProducesResponseType(typeof(IReadOnlyList<ExpensePaymentDto>), StatusCodes.Status200OK)]
    [ProducesResponseType(StatusCodes.Status404NotFound)]
    public async Task<ActionResult<IReadOnlyList<ExpensePaymentDto>>> ListPayments(int expenseId, CancellationToken ct)
        => Ok(await _payments.ListAsync(expenseId, ct));
 }
@@ -1,53 +0,0 @@
 using ERPCore.Dtos.Config;
 using ERPCore.Infra.Auth;
 using ERPCore.Services.Interfaces;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 namespace ERPCore.Controllers;
 /// <summary>
 /// Role → GL account mapping endpoints.
 /// <para>
 /// <b>Authorization:</b> the <c>settings</c> nav policy, like <see cref="BranchConfigController"/>.
 /// Note this endpoint also serves the selectable accounts, rather than the screen calling the GL
 /// proxy directly: <see cref="GeneralLedgerController"/> is gated on <c>ledgers</c>, so a
 /// settings-only user would get a 403 from it — and serving both from here guarantees the picker
 /// and the server-side validation work from the same list.
 /// </para>
 /// </summary>
 [Route("api/v1/gl-account-config")]
 [Authorize(Policy = NavPolicies.Prefix + "settings")]
 public sealed class GlAccountConfigController : ApiControllerBase
 {
    private readonly IGlAccountConfigService _config;
    public GlAccountConfigController(IGlAccountConfigService config) => _config = config;
    [HttpGet]
    [ProducesResponseType(typeof(GlAccountConfigDto), StatusCodes.Status200OK)]
    public async Task<ActionResult<GlAccountConfigDto>> Get(CancellationToken ct)
    {
        var result = await _config.GetAsync(ct);
        SetETag(result.RowVersion);
        return Ok(result.Value);
    }
    /// <summary>
    /// Replaces the mapping. 422 when a code is unknown to GL or not postable; 503 when GL could
    /// not be reached, since a mapping that could not be verified is not stored.
    /// </summary>
    [HttpPut]
    [ProducesResponseType(typeof(GlAccountConfigDto), StatusCodes.Status200OK)]
    [ProducesResponseType(StatusCodes.Status412PreconditionFailed)]
    [ProducesResponseType(StatusCodes.Status422UnprocessableEntity)]
    [ProducesResponseType(StatusCodes.Status503ServiceUnavailable)]
    public async Task<ActionResult<GlAccountConfigDto>> Update(
        [FromBody] UpdateGlAccountConfigRequest request, CancellationToken ct)
    {
        var expected = RequireIfMatch();
        var result = await _config.UpdateAsync(request, expected, ct);
        SetETag(result.RowVersion);
        return Ok(result.Value);
    }
 }
@@ -1,45 +0,0 @@
 using Microsoft.AspNetCore.Authorization;
 using ERPCore.Infra.Auth;
 using ERPCore.Dtos.Config;
 using ERPCore.Services.Interfaces;
 using Microsoft.AspNetCore.Mvc;
 namespace ERPCore.Controllers;
 /// <summary>
 /// GRN configuration endpoints — warehouse selection and the default receiving warehouse.
 /// <para>
 /// <b>Authorization:</b> gated on the Receiving nav policy (the New GRN form has to read it), same
 /// Phase-1 posture as <see cref="SalesConfigController"/>.
 /// </para>
 /// </summary>
 [Route("api/v1/grn-config")]
 [Authorize(Policy = NavPolicies.Prefix + "receiving")]
 public sealed class GrnConfigController : ApiControllerBase
 {
    private readonly IGrnConfigService _config;
    public GrnConfigController(IGrnConfigService config) => _config = config;
    [HttpGet]
    [ProducesResponseType(typeof(GrnConfigDto), StatusCodes.Status200OK)]
    public async Task<ActionResult<GrnConfigDto>> Get(CancellationToken ct)
    {
        var result = await _config.GetAsync(ct);
        SetETag(result.RowVersion);
        return Ok(result.Value);
    }
    [HttpPut]
    [ProducesResponseType(typeof(GrnConfigDto), StatusCodes.Status200OK)]
    [ProducesResponseType(StatusCodes.Status400BadRequest)]
    [ProducesResponseType(StatusCodes.Status412PreconditionFailed)]
    public async Task<ActionResult<GrnConfigDto>> Update(
        [FromBody] UpdateGrnConfigRequest request, CancellationToken ct)
    {
        var expected = RequireIfMatch();
        var result = await _config.UpdateAsync(request, expected, ct);
        SetETag(result.RowVersion);
        return Ok(result.Value);
    }
 }
@@ -1,64 +0,0 @@
 using ERPCore.Dtos.Items;
 using ERPCore.Infra.Auth;
 using ERPCore.Services;
 using ERPCore.Services.Interfaces;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 namespace ERPCore.Controllers;
 /// <summary>Item photos. Same access as the item master itself.</summary>
 [Route("api/v1/items/{itemId:int}/images")]
 [Authorize(Policy = NavPolicies.Prefix + "products")]
 public sealed class ItemImagesController : ApiControllerBase
 {
    private readonly IItemImageService _images;
    private readonly ICurrentUser _currentUser;
    public ItemImagesController(IItemImageService images, ICurrentUser currentUser)
    {
        _images = images;
        _currentUser = currentUser;
    }
    [HttpGet]
    [ProducesResponseType(typeof(List<ItemImageDto>), StatusCodes.Status200OK)]
    [ProducesResponseType(StatusCodes.Status404NotFound)]
    public async Task<ActionResult<List<ItemImageDto>>> List(int itemId, CancellationToken ct)
        => Ok(await _images.ListAsync(itemId, ct));
    /// <summary>Upload one image (multipart <c>file</c>). 422 CONFIG_DISABLED while item images are off.</summary>
    [HttpPost]
    [RequestSizeLimit(ItemImageService.MaxSizeBytes + 64 * 1024)]
    [ProducesResponseType(typeof(ItemImageDto), StatusCodes.Status201Created)]
    [ProducesResponseType(StatusCodes.Status404NotFound)]
    [ProducesResponseType(StatusCodes.Status413PayloadTooLarge)]
    [ProducesResponseType(StatusCodes.Status422UnprocessableEntity)]
    public async Task<ActionResult<ItemImageDto>> Upload(int itemId, IFormFile file, CancellationToken ct)
    {
        await using var stream = file.OpenReadStream();
        var result = await _images.UploadAsync(itemId, stream, file.FileName, file.ContentType, _currentUser.AuditUserId, ct);
        return Created($"/api/v1/items/{itemId}/images/{result.ItemImageId}", result);
    }
    /// <summary>The image bytes, served inline so an &lt;img&gt; can point straight at it.</summary>
    [HttpGet("{itemImageId:int}/content")]
    [ProducesResponseType(StatusCodes.Status200OK)]
    [ProducesResponseType(StatusCodes.Status404NotFound)]
    public async Task<IActionResult> Content(int itemId, int itemImageId, CancellationToken ct)
    {
        var (content, contentType) = await _images.OpenAsync(itemId, itemImageId, ct);
        // Stored files are immutable (new upload ⇒ new id), so the browser may cache them.
        Response.Headers.CacheControl = "private, max-age=86400";
        return File(content, contentType);
    }
    [HttpDelete("{itemImageId:int}")]
    [ProducesResponseType(StatusCodes.Status204NoContent)]
    [ProducesResponseType(StatusCodes.Status404NotFound)]
    public async Task<IActionResult> Delete(int itemId, int itemImageId, CancellationToken ct)
    {
        await _images.DeleteAsync(itemId, itemImageId, ct);
        return NoContent();
    }
 }
@@ -40,11 +40,8 @@ public sealed class ItemsController : ApiControllerBase
        [FromQuery] int? categoryId,
        [FromQuery] int? subCategoryId,
        [FromQuery] int? brandId,
        [FromQuery] TrackingMode? trackingMode,
        [FromQuery] StockNature? stockNature,
        [FromQuery] ItemStockFilter? stock,
        CancellationToken ct)
-        => Ok(await _items.GetOverviewAsync(query, status, categoryId, subCategoryId, brandId, trackingMode, stockNature, stock, ct));
+        => Ok(await _items.GetOverviewAsync(query, status, categoryId, subCategoryId, brandId, ct));
    /// <summary>Barcode/RFID lookup — matches an item's barcode/SKU, or a batch/serial
    /// barcode/no (optionally scoped to <paramref name="itemId"/> first).</summary>
@@ -57,13 +54,6 @@ public sealed class ItemsController : ApiControllerBase
        return result is null ? NotFound() : Ok(result);
    }
    /// <summary>The item's latest posted GRN receipts (default 5, newest first): unit cost, discount, net cost, vendor.</summary>
    [HttpGet("{itemId:int}/purchase-prices")]
    [ProducesResponseType(typeof(IReadOnlyList<ItemPurchasePriceDto>), StatusCodes.Status200OK)]
    [ProducesResponseType(StatusCodes.Status404NotFound)]
    public async Task<ActionResult<IReadOnlyList<ItemPurchasePriceDto>>> PurchasePrices(int itemId, [FromQuery] int take, CancellationToken ct)
        => Ok(await _items.GetPurchasePricesAsync(itemId, take <= 0 ? 5 : take, ct));
    /// <summary>Get a single item; returns an <c>ETag</c> for optimistic concurrency.</summary>
    [HttpGet("{itemId:int}")]
    [ProducesResponseType(typeof(ItemDetailDto), StatusCodes.Status200OK)]
@@ -1,89 +0,0 @@
 using Microsoft.AspNetCore.Authorization;
 using ERPCore.Domain.Enums;
 using ERPCore.Dtos.Approvals;
 using ERPCore.Dtos.Common;
 using ERPCore.Dtos.Products;
 using ERPCore.Infra.Auth;
 using ERPCore.Services.Interfaces;
 using Microsoft.AspNetCore.Mvc;
 namespace ERPCore.Controllers;
 /// <summary>
 /// Selling-price change requests (docs/DUAL_APPROVAL_PLAN.md §6.4). Requesting needs Create on
 /// <c>products.price-adjustments</c>, deciding needs Approve; an item's applied price history is
 /// readable by anyone who can see Products.
 /// </summary>
 [Route("api/v1/price-adjustments")]
 [Authorize(Policy = NavPolicies.Prefix + "products")]
 public sealed class PriceAdjustmentsController : ApiControllerBase
 {
    private const string Screen = NavPolicies.Prefix + "products.price-adjustments";
    private const string CreatePolicy = Screen + NavPolicies.ActionSeparator + NavPolicies.CreateAction;
    private const string ApprovePolicy = Screen + NavPolicies.ActionSeparator + NavPolicies.ApproveAction;
    private readonly IPriceAdjustmentService _prices;
    public PriceAdjustmentsController(IPriceAdjustmentService prices) => _prices = prices;
    [HttpGet]
    [Authorize(Policy = Screen)]
    [ProducesResponseType(typeof(PagedResponse<PriceAdjustmentSummaryDto>), StatusCodes.Status200OK)]
    public async Task<ActionResult<PagedResponse<PriceAdjustmentSummaryDto>>> List(
        [FromQuery] PageQuery query, [FromQuery] PriceAdjustmentStatus? status, [FromQuery] int? itemId, CancellationToken ct)
        => Ok(await _prices.ListAsync(query, status, itemId, ct));
    [HttpGet("{priceAdjustmentId:int}")]
    [Authorize(Policy = Screen)]
    [ProducesResponseType(typeof(PriceAdjustmentDto), StatusCodes.Status200OK)]
    [ProducesResponseType(StatusCodes.Status404NotFound)]
    public async Task<ActionResult<PriceAdjustmentDto>> GetById(int priceAdjustmentId, CancellationToken ct)
    {
        var dto = await _prices.GetAsync(priceAdjustmentId, ct);
        return dto is null ? NotFound() : Ok(dto);
    }
    /// <summary>Request new selling prices for one or more items.</summary>
    [HttpPost]
    [Authorize(Policy = CreatePolicy)]
    [ProducesResponseType(typeof(PriceAdjustmentDto), StatusCodes.Status201Created)]
    [ProducesResponseType(StatusCodes.Status400BadRequest)]
    [ProducesResponseType(StatusCodes.Status409Conflict)]
    public async Task<ActionResult<PriceAdjustmentDto>> Create([FromBody] CreatePriceAdjustmentRequest request, CancellationToken ct)
    {
        var dto = await _prices.CreateAsync(request, ct);
        return Created($"/api/v1/price-adjustments/{dto.PriceAdjustmentId}", dto);
    }
    /// <summary>Give the next approval; the final one applies the prices.</summary>
    [HttpPost("{priceAdjustmentId:int}/approve")]
    [Authorize(Policy = ApprovePolicy)]
    [ProducesResponseType(typeof(PriceAdjustmentDto), StatusCodes.Status200OK)]
    [ProducesResponseType(StatusCodes.Status403Forbidden)]
    [ProducesResponseType(StatusCodes.Status409Conflict)]
    public async Task<ActionResult<PriceAdjustmentDto>> Approve(int priceAdjustmentId, [FromBody] ApproveRequest? request, CancellationToken ct)
        => Ok(await _prices.ApproveAsync(priceAdjustmentId, request?.Comment, ct));
    [HttpPost("{priceAdjustmentId:int}/reject")]
    [Authorize(Policy = ApprovePolicy)]
    [ProducesResponseType(typeof(PriceAdjustmentDto), StatusCodes.Status200OK)]
    [ProducesResponseType(StatusCodes.Status403Forbidden)]
    [ProducesResponseType(StatusCodes.Status409Conflict)]
    public async Task<ActionResult<PriceAdjustmentDto>> Reject(int priceAdjustmentId, [FromBody] RejectRequest request, CancellationToken ct)
        => Ok(await _prices.RejectAsync(priceAdjustmentId, request.Reason, ct));
    /// <summary>The requester withdraws a pending request.</summary>
    [HttpPost("{priceAdjustmentId:int}/cancel")]
    [Authorize(Policy = Screen)]
    [ProducesResponseType(typeof(PriceAdjustmentDto), StatusCodes.Status200OK)]
    [ProducesResponseType(StatusCodes.Status403Forbidden)]
    [ProducesResponseType(StatusCodes.Status409Conflict)]
    public async Task<ActionResult<PriceAdjustmentDto>> Cancel(int priceAdjustmentId, CancellationToken ct)
        => Ok(await _prices.CancelAsync(priceAdjustmentId, ct));
    /// <summary>Every applied price change for an item, newest first, with who approved it.</summary>
    [HttpGet("/api/v1/items/{itemId:int}/price-history")]
    [ProducesResponseType(typeof(IReadOnlyList<ItemPriceHistoryDto>), StatusCodes.Status200OK)]
    public async Task<ActionResult<IReadOnlyList<ItemPriceHistoryDto>>> ItemHistory(int itemId, CancellationToken ct)
        => Ok(await _prices.ItemHistoryAsync(itemId, ct));
 }
@@ -45,4 +45,5 @@ public sealed class ProductConfigController : ApiControllerBase
        var result = await _config.UpdateAsync(request, expected, ct);
        SetETag(result.RowVersion);
        return Ok(result.Value);
-    }}
+    }
 }
@@ -56,7 +56,6 @@ public sealed class ProductionRunsController : ApiControllerBase
    [ProducesResponseType(typeof(RunGraphDto), StatusCodes.Status201Created)]
    [ProducesResponseType(StatusCodes.Status404NotFound)]
    [ProducesResponseType(StatusCodes.Status422UnprocessableEntity)]
    [ProducesResponseType(StatusCodes.Status412PreconditionFailed)]
    public async Task<ActionResult<RunGraphDto>> Create([FromBody] CreateRunRequest request, CancellationToken ct)
    {
        var result = await _runs.CreateAsync(request, ct);
@@ -70,7 +69,6 @@ public sealed class ProductionRunsController : ApiControllerBase
    [ProducesResponseType(StatusCodes.Status404NotFound)]
    [ProducesResponseType(StatusCodes.Status409Conflict)]
    [ProducesResponseType(StatusCodes.Status422UnprocessableEntity)]
    [ProducesResponseType(StatusCodes.Status412PreconditionFailed)]
    public async Task<ActionResult<RunStageDto>> UpdateQuantities(
        int runId, int runStageId, [FromBody] UpdateStageQuantitiesRequest request, CancellationToken ct)
        => Ok(await _runs.UpdateStageQuantitiesAsync(runId, runStageId, request, ct));
@@ -88,7 +86,6 @@ public sealed class ProductionRunsController : ApiControllerBase
    [ProducesResponseType(StatusCodes.Status404NotFound)]
    [ProducesResponseType(StatusCodes.Status409Conflict)]
    [ProducesResponseType(StatusCodes.Status422UnprocessableEntity)]
    [ProducesResponseType(StatusCodes.Status412PreconditionFailed)]
    public async Task<ActionResult<StartStageResultDto>> Start(
        int runId, int runStageId,
        [FromHeader(Name = "Idempotency-Key")] string? idempotencyKey,
@@ -101,7 +98,6 @@ public sealed class ProductionRunsController : ApiControllerBase
    [ProducesResponseType(StatusCodes.Status404NotFound)]
    [ProducesResponseType(StatusCodes.Status409Conflict)]
    [ProducesResponseType(StatusCodes.Status422UnprocessableEntity)]
    [ProducesResponseType(StatusCodes.Status412PreconditionFailed)]
    public async Task<ActionResult<RunStageDto>> Complete(
        int runId, int runStageId, [FromBody] CompleteStageRequest request,
        [FromHeader(Name = "Idempotency-Key")] string? idempotencyKey,
@@ -113,7 +109,6 @@ public sealed class ProductionRunsController : ApiControllerBase
    [ProducesResponseType(StatusCodes.Status404NotFound)]
    [ProducesResponseType(StatusCodes.Status409Conflict)]
    [ProducesResponseType(StatusCodes.Status422UnprocessableEntity)]
    [ProducesResponseType(StatusCodes.Status412PreconditionFailed)]
    public async Task<ActionResult<ApproveStageResultDto>> Approve(
        int runId, int runStageId, [FromBody] ApproveStageRequest? request,
        [FromHeader(Name = "Idempotency-Key")] string? idempotencyKey,
@@ -125,7 +120,6 @@ public sealed class ProductionRunsController : ApiControllerBase
    [ProducesResponseType(StatusCodes.Status404NotFound)]
    [ProducesResponseType(StatusCodes.Status409Conflict)]
    [ProducesResponseType(StatusCodes.Status422UnprocessableEntity)]
    [ProducesResponseType(StatusCodes.Status412PreconditionFailed)]
    public async Task<ActionResult<TransferResultDto>> Transfer(
        int runId, int runStageId, [FromBody] TransferRemainderRequest request,
        [FromHeader(Name = "Idempotency-Key")] string? idempotencyKey,
@@ -138,7 +132,6 @@ public sealed class ProductionRunsController : ApiControllerBase
    [ProducesResponseType(StatusCodes.Status404NotFound)]
    [ProducesResponseType(StatusCodes.Status409Conflict)]
    [ProducesResponseType(StatusCodes.Status422UnprocessableEntity)]
    [ProducesResponseType(StatusCodes.Status412PreconditionFailed)]
    public async Task<ActionResult<ReturnLeftoverResultDto>> ReturnLeftover(
        int runId, int runInputId, [FromBody] ReturnLeftoverRequest request,
        [FromHeader(Name = "Idempotency-Key")] string? idempotencyKey,
@@ -149,7 +142,6 @@ public sealed class ProductionRunsController : ApiControllerBase
    [ProducesResponseType(typeof(RejectIntakeResultDto), StatusCodes.Status200OK)]
    [ProducesResponseType(StatusCodes.Status404NotFound)]
    [ProducesResponseType(StatusCodes.Status409Conflict)]
    [ProducesResponseType(StatusCodes.Status412PreconditionFailed)]
    public async Task<ActionResult<RejectIntakeResultDto>> RejectIntake(
        int runId, int runStageId, [FromBody] RejectRequest? request,
        [FromHeader(Name = "Idempotency-Key")] string? idempotencyKey,
@@ -161,7 +153,6 @@ public sealed class ProductionRunsController : ApiControllerBase
    [ProducesResponseType(typeof(TerminalRejectResultDto), StatusCodes.Status200OK)]
    [ProducesResponseType(StatusCodes.Status404NotFound)]
    [ProducesResponseType(StatusCodes.Status409Conflict)]
    [ProducesResponseType(StatusCodes.Status412PreconditionFailed)]
    public async Task<ActionResult<TerminalRejectResultDto>> Reject(
        int runId, int runStageId, [FromBody] RejectRequest? request,
        [FromHeader(Name = "Idempotency-Key")] string? idempotencyKey,
@@ -174,7 +165,6 @@ public sealed class ProductionRunsController : ApiControllerBase
    [ProducesResponseType(StatusCodes.Status404NotFound)]
    [ProducesResponseType(StatusCodes.Status409Conflict)]
    [ProducesResponseType(StatusCodes.Status422UnprocessableEntity)]
    [ProducesResponseType(StatusCodes.Status412PreconditionFailed)]
    public async Task<ActionResult<CancelRunResultDto>> Cancel(
        int runId, [FromBody] CancelRunRequest request,
        [FromHeader(Name = "Idempotency-Key")] string? idempotencyKey,
@@ -1,46 +0,0 @@
 using Microsoft.AspNetCore.Authorization;
 using ERPCore.Infra.Auth;
 using ERPCore.Dtos.Config;
 using ERPCore.Services.Interfaces;
 using Microsoft.AspNetCore.Mvc;
 namespace ERPCore.Controllers;
 /// <summary>
 /// Sales configuration endpoints — the singleton "allow cash customer" toggle.
 /// <para>
 /// <b>Authorization:</b> gated on the Sales nav policy (the New Sale form has to read it), same
 /// Phase-1 posture as <see cref="BranchConfigController"/> — any Sales user can flip the flag
 /// until per-endpoint RBAC lands.
 /// </para>
 /// </summary>
 [Route("api/v1/sales-config")]
 [Authorize(Policy = NavPolicies.Prefix + "sales")]
 public sealed class SalesConfigController : ApiControllerBase
 {
    private readonly ISalesConfigService _config;
    public SalesConfigController(ISalesConfigService config) => _config = config;
    [HttpGet]
    [ProducesResponseType(typeof(SalesConfigDto), StatusCodes.Status200OK)]
    public async Task<ActionResult<SalesConfigDto>> Get(CancellationToken ct)
    {
        var result = await _config.GetAsync(ct);
        SetETag(result.RowVersion);
        return Ok(result.Value);
    }
    [HttpPut]
    [ProducesResponseType(typeof(SalesConfigDto), StatusCodes.Status200OK)]
    [ProducesResponseType(StatusCodes.Status400BadRequest)]
    [ProducesResponseType(StatusCodes.Status412PreconditionFailed)]
    public async Task<ActionResult<SalesConfigDto>> Update(
        [FromBody] UpdateSalesConfigRequest request, CancellationToken ct)
    {
        var expected = RequireIfMatch();
        var result = await _config.UpdateAsync(request, expected, ct);
        SetETag(result.RowVersion);
        return Ok(result.Value);
    }
 }
@@ -14,70 +14,11 @@ public sealed class SalesInvoicesController : ApiControllerBase
 {
    private readonly ISalesInvoiceService _invoices;
    private readonly ISalesInvoicePaymentService _payments;
    private readonly ISalesPricingService _pricing;
    private readonly ISalesDomainService _sales;
    private readonly IStockService _stock;
-    public SalesInvoicesController(
+    public SalesInvoicesController(ISalesInvoiceService invoices, ISalesInvoicePaymentService payments)
        ISalesInvoiceService invoices, ISalesInvoicePaymentService payments, ISalesPricingService pricing,
        ISalesDomainService sales, IStockService stock)
    {
        _invoices = invoices;
        _payments = payments;
        _pricing = pricing;
        _sales = sales;
        _stock = stock;
    }
    // Lets the New Sale form warn, per line, when qty exceeds the stock a sale can issue — under
    // the "sales" policy, since sales users may not hold the "stock" nav permission. Non-stocked
    // items (services) are never short, so they report IsStocked = false and no limit.
    [HttpGet("stock-availability")]
    [ProducesResponseType(typeof(SalesStockAvailabilityDto), StatusCodes.Status200OK)]
    [ProducesResponseType(StatusCodes.Status404NotFound)]
    public async Task<ActionResult<SalesStockAvailabilityDto>> StockAvailability(
        [FromQuery] int itemId, [FromQuery] int warehouseId, CancellationToken ct)
    {
        bool isStocked;
        try
        {
            isStocked = await _sales.IsStockedItemAsync(itemId, ct);
        }
        catch (InvalidOperationException)
        {
            return NotFound();
        }
        var available = isStocked ? (await _stock.GetOnHandAsync(itemId, warehouseId, ct)).Available : 0m;
        return Ok(new SalesStockAvailabilityDto(itemId, warehouseId, isStocked, available));
    }
    // Feeds New Sale's "Add item" dropdown with each item's issuable stock at the sale's warehouse.
    // Under "sales" for the same reason as above; items absent from the list have no stock there.
    [HttpGet("stock-summary")]
    [ProducesResponseType(typeof(IReadOnlyList<SalesItemStockDto>), StatusCodes.Status200OK)]
    public async Task<ActionResult<IReadOnlyList<SalesItemStockDto>>> StockSummary([FromQuery] int warehouseId, CancellationToken ct)
    {
        var available = await _stock.GetAvailableByItemAsync(warehouseId, ct);
        return Ok(available.Select(kv => new SalesItemStockDto(kv.Key, kv.Value)).ToList());
    }
    // Lets the New Sale form pre-fill Unit price for items with no flat selling price, using the
    // same resolution the server applies on save.
    [HttpGet("suggested-price")]
    [ProducesResponseType(typeof(SalesSuggestedPriceDto), StatusCodes.Status200OK)]
    [ProducesResponseType(StatusCodes.Status404NotFound)]
    public async Task<ActionResult<SalesSuggestedPriceDto>> SuggestedPrice(
        [FromQuery] int itemId, [FromQuery] int warehouseId, CancellationToken ct)
    {
        try
        {
            var price = await _pricing.ResolveAsync(itemId, warehouseId, null, false, ct);
            return Ok(new SalesSuggestedPriceDto(itemId, warehouseId, price.UnitPrice, price.PriceSource));
        }
        catch (InvalidOperationException)
        {
            return NotFound();
        }
    }
    [HttpGet]
@@ -90,10 +31,8 @@ public sealed class SalesInvoicesController : ApiControllerBase
        [FromQuery] int? branchId,
        [FromQuery] DateOnly? from,
        [FromQuery] DateOnly? to,
        [FromQuery] int? createdBy,
        [FromQuery] bool? paid,
        CancellationToken ct)
-        => Ok(await _invoices.ListAsync(query, status, customerId, warehouseId, branchId, from, to, createdBy, paid, ct));
+        => Ok(await _invoices.ListAsync(query, status, customerId, warehouseId, branchId, from, to, ct));
    [HttpGet("{salesInvoiceId:int}")]
    [ProducesResponseType(typeof(SalesInvoiceDto), StatusCodes.Status200OK)]
@@ -155,18 +94,6 @@ public sealed class SalesInvoicesController : ApiControllerBase
        return Created($"/api/v1/sales-invoices/{salesInvoiceId}/payments/{dto.SalesInvoicePaymentId}", dto);
    }
    /// <summary>
    /// Pay several Posted invoices of one (non-cash) customer at once, split across payment lines;
    /// applied oldest invoice first under a single GL journal entry. Returns one payment per split.
    /// </summary>
    [HttpPost("payments/bulk")]
    [ProducesResponseType(typeof(IReadOnlyList<SalesInvoicePaymentDto>), StatusCodes.Status200OK)]
    [ProducesResponseType(StatusCodes.Status400BadRequest)]
    [ProducesResponseType(StatusCodes.Status404NotFound)]
    [ProducesResponseType(StatusCodes.Status409Conflict)]
    public async Task<ActionResult<IReadOnlyList<SalesInvoicePaymentDto>>> PayBulk([FromBody] CreateBulkSalesInvoicePaymentRequest request, CancellationToken ct)
        => Ok(await _payments.PayBulkAsync(request, ct));
    /// <summary>Payment history for this invoice, newest first.</summary>
    [HttpGet("{salesInvoiceId:int}/payments")]
    [ProducesResponseType(typeof(IReadOnlyList<SalesInvoicePaymentDto>), StatusCodes.Status200OK)]
@@ -1,41 +0,0 @@
 using ERPCore.Domain.Enums;
 using ERPCore.Dtos.Common;
 using ERPCore.Dtos.Stock;
 using ERPCore.Infra.Auth;
 using ERPCore.Services.Interfaces;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 namespace ERPCore.Controllers;
 /// <summary>Serial register and per-serial history (docs/ITEM_TRACKING_PLAN.md Phase 9).</summary>
 [Route("api/v1/serials")]
 [Authorize(Policy = NavPolicies.Prefix + "stock")]
 public sealed class SerialsController : ApiControllerBase
 {
    private readonly IItemTrackingService _tracking;
    public SerialsController(IItemTrackingService tracking) => _tracking = tracking;
    [HttpGet]
    [ProducesResponseType(typeof(PagedResponse<SerialSummaryDto>), StatusCodes.Status200OK)]
    public async Task<ActionResult<PagedResponse<SerialSummaryDto>>> List(
        [FromQuery] int? itemId, [FromQuery] int? warehouseId, [FromQuery] SerialStatus? status,
        [FromQuery] PageQuery query, CancellationToken ct)
        => Ok(await _tracking.ListSerialsAsync(query, itemId, warehouseId, status, ct));
    /// <summary>Exact lookup by serial number or barcode, across items.</summary>
    [HttpGet("lookup")]
    [ProducesResponseType(typeof(IReadOnlyList<SerialDetailDto>), StatusCodes.Status200OK)]
    public async Task<ActionResult<IReadOnlyList<SerialDetailDto>>> Lookup([FromQuery] string serialNo, CancellationToken ct)
        => Ok(await _tracking.FindSerialAsync(serialNo, ct));
    [HttpGet("{serialId:int}")]
    [ProducesResponseType(typeof(SerialDetailDto), StatusCodes.Status200OK)]
    [ProducesResponseType(StatusCodes.Status404NotFound)]
    public async Task<ActionResult<SerialDetailDto>> Get(int serialId, CancellationToken ct)
    {
        var dto = await _tracking.GetSerialAsync(serialId, ct);
        return dto is null ? NotFound() : Ok(dto);
    }
 }
@@ -1,7 +1,5 @@
 using Microsoft.AspNetCore.Authorization;
 using ERPCore.Domain.Enums;
 using ERPCore.Infra.Auth;
 using ERPCore.Dtos.Approvals;
 using ERPCore.Dtos.Common;
 using ERPCore.Dtos.Stock;
 using ERPCore.Services.Interfaces;
@@ -9,30 +7,23 @@ using Microsoft.AspNetCore.Mvc;
 namespace ERPCore.Controllers;
-/// <summary>
+/// <summary>Stock-adjustment endpoints (docs/11 §5.5).</summary>
 /// Stock-adjustment endpoints (docs/11 §5.5). Creating submits a request; it moves stock once
 /// approved (docs/DUAL_APPROVAL_PLAN.md §5.4). Approving or rejecting needs the Approve action on
 /// <c>stock.adjustments</c>; the two-person rules are enforced by the service.
 /// </summary>
 [Route("api/v1/stock-adjustments")]
 [Authorize(Policy = NavPolicies.Prefix + "stock")]
 public sealed class StockAdjustmentsController : ApiControllerBase
 {
    private const string ApprovePolicy = NavPolicies.Prefix + "stock.adjustments" + NavPolicies.ActionSeparator + NavPolicies.ApproveAction;
    private readonly IAdjustmentService _adjustments;
    public StockAdjustmentsController(IAdjustmentService adjustments) => _adjustments = adjustments;
-    /// <summary>List adjustments (posted and requests), newest first.</summary>
+    /// <summary>List posted adjustments, newest first.</summary>
    [HttpGet]
    [ProducesResponseType(typeof(PagedResponse<AdjustmentSummaryDto>), StatusCodes.Status200OK)]
    public async Task<ActionResult<PagedResponse<AdjustmentSummaryDto>>> List(
-        [FromQuery] PageQuery query, [FromQuery] int? warehouseId, [FromQuery] int? branchId, [FromQuery] int? reasonCodeId,
+        [FromQuery] PageQuery query, [FromQuery] int? warehouseId, [FromQuery] int? branchId, [FromQuery] int? reasonCodeId, CancellationToken ct)
-        [FromQuery] AdjustmentStatus? status, CancellationToken ct)
+        => Ok(await _adjustments.ListAsync(query, warehouseId, branchId, reasonCodeId, ct));
        => Ok(await _adjustments.ListAsync(query, warehouseId, branchId, reasonCodeId, status, ct));
-    /// <summary>Get one adjustment with its lines, approval trail and the ledger entries it posted.</summary>
+    /// <summary>Get one adjustment with its lines and the ledger entries it posted.</summary>
    [HttpGet("{adjustmentId:int}")]
    [ProducesResponseType(typeof(AdjustmentDto), StatusCodes.Status200OK)]
    [ProducesResponseType(StatusCodes.Status404NotFound)]
@@ -42,7 +33,7 @@ public sealed class StockAdjustmentsController : ApiControllerBase
        return dto is null ? NotFound() : Ok(dto);
    }
-    /// <summary>Submit an adjustment (mandatory reason code). Posts at once only when approvals are off.</summary>
+    /// <summary>Create + auto-post an adjustment (mandatory reason code; decrease FIFO-consumes).</summary>
    [HttpPost]
    [ProducesResponseType(typeof(AdjustmentDto), StatusCodes.Status201Created)]
    [ProducesResponseType(StatusCodes.Status400BadRequest)]
@@ -53,29 +44,4 @@ public sealed class StockAdjustmentsController : ApiControllerBase
        var dto = await _adjustments.CreateAsync(request, ct);
        return Created($"/api/v1/stock-adjustments/{dto.AdjustmentId}", dto);
    }
    /// <summary>Give the next approval. The final one posts the stock movement and GL.</summary>
    [HttpPost("{adjustmentId:int}/approve")]
    [Authorize(Policy = ApprovePolicy)]
    [ProducesResponseType(typeof(AdjustmentDto), StatusCodes.Status200OK)]
    [ProducesResponseType(StatusCodes.Status403Forbidden)]
    [ProducesResponseType(StatusCodes.Status409Conflict)]
    public async Task<ActionResult<AdjustmentDto>> Approve(int adjustmentId, [FromBody] ApproveRequest? request, CancellationToken ct)
        => Ok(await _adjustments.ApproveAsync(adjustmentId, request?.Comment, ct));
    [HttpPost("{adjustmentId:int}/reject")]
    [Authorize(Policy = ApprovePolicy)]
    [ProducesResponseType(typeof(AdjustmentDto), StatusCodes.Status200OK)]
    [ProducesResponseType(StatusCodes.Status403Forbidden)]
    [ProducesResponseType(StatusCodes.Status409Conflict)]
    public async Task<ActionResult<AdjustmentDto>> Reject(int adjustmentId, [FromBody] RejectRequest request, CancellationToken ct)
        => Ok(await _adjustments.RejectAsync(adjustmentId, request.Reason, ct));
    /// <summary>The requester withdraws a pending request.</summary>
    [HttpPost("{adjustmentId:int}/cancel")]
    [ProducesResponseType(typeof(AdjustmentDto), StatusCodes.Status200OK)]
    [ProducesResponseType(StatusCodes.Status403Forbidden)]
    [ProducesResponseType(StatusCodes.Status409Conflict)]
    public async Task<ActionResult<AdjustmentDto>> Cancel(int adjustmentId, CancellationToken ct)
        => Ok(await _adjustments.CancelAsync(adjustmentId, ct));
 }
@@ -15,26 +15,13 @@ public sealed class StockController : ApiControllerBase
 {
    private readonly IStockService _stock;
    private readonly IReorderService _reorder;
    private readonly IItemTrackingService _tracking;
-    public StockController(IStockService stock, IReorderService reorder, IItemTrackingService tracking)
+    public StockController(IStockService stock, IReorderService reorder)
    {
        _stock = stock;
        _reorder = reorder;
        _tracking = tracking;
    }
    /// <summary>
    /// Stock on hand per batch with expiry (docs/ITEM_TRACKING_PLAN.md Phase 9), soonest expiry
    /// first. <c>expiringWithinDays</c> keeps batches expiring within that window, expired included.
    /// </summary>
    [HttpGet("batches")]
    [ProducesResponseType(typeof(PagedResponse<BatchStockDto>), StatusCodes.Status200OK)]
    public async Task<ActionResult<PagedResponse<BatchStockDto>>> Batches(
        [FromQuery] int? itemId, [FromQuery] int? warehouseId, [FromQuery] int? expiringWithinDays,
        [FromQuery] PageQuery query, CancellationToken ct)
        => Ok(await _tracking.ListBatchStockAsync(query, itemId, warehouseId, expiringWithinDays, ct));
    [HttpGet("on-hand")]
    [ProducesResponseType(typeof(StockOnHandDto), StatusCodes.Status200OK)]
    public async Task<ActionResult<StockOnHandDto>> OnHand([FromQuery] int itemId, [FromQuery] int warehouseId, CancellationToken ct)
@@ -1,64 +0,0 @@
 using ERPCore.Dtos.Stock;
 using ERPCore.Services.Interfaces;
 using Microsoft.AspNetCore.Mvc;
 namespace ERPCore.Controllers;
 /// <summary>
 /// Serial/batch pickers used across GRN, sales, returns and stock screens
 /// (docs/ITEM_TRACKING_PLAN.md Phase 8). Read-only lookups like the item scan, so they need
 /// only ERP access — not one module's nav permission — as every one of those screens calls them.
 /// </summary>
 [Route("api/v1/tracking")]
 public sealed class TrackingController : ApiControllerBase
 {
    private readonly IItemTrackingService _tracking;
    private readonly ISerialTrackingService _serialTracking;
    public TrackingController(IItemTrackingService tracking, ISerialTrackingService serialTracking)
    {
        _tracking = tracking;
        _serialTracking = serialTracking;
    }
    /// <summary>
    /// Which tracking features are switched on (Product Configuration) — readable by every
    /// screen, unlike <c>/product-config</c> which needs the Products permission.
    /// </summary>
    [HttpGet("settings")]
    [ProducesResponseType(typeof(TrackingSettingsDto), StatusCodes.Status200OK)]
    public async Task<ActionResult<TrackingSettingsDto>> Settings(CancellationToken ct)
        => Ok(new TrackingSettingsDto(await _serialTracking.IsEnabledAsync(ct)));
    /// <summary>
    /// Auto-generate: the next <c>count</c> free serial numbers for an item under <c>prefix</c>
    /// (continues the highest number already used). Nothing is reserved — the GRN still checks
    /// uniqueness when it is saved and confirmed.
    /// </summary>
    [HttpGet("serials/next-numbers")]
    [ProducesResponseType(typeof(IReadOnlyList<string>), StatusCodes.Status200OK)]
    public async Task<ActionResult<IReadOnlyList<string>>> NextSerialNumbers(
        [FromQuery] int itemId, [FromQuery] string? prefix, [FromQuery] int count = 1, CancellationToken ct = default)
        => Ok(await _tracking.NextSerialNumbersAsync(itemId, prefix ?? string.Empty, count, ct));
    /// <summary>Issuable serials of an item at a warehouse (search by number/barcode with <c>q</c>).</summary>
    [HttpGet("serials/available")]
    [ProducesResponseType(typeof(IReadOnlyList<AvailableSerialDto>), StatusCodes.Status200OK)]
    public async Task<ActionResult<IReadOnlyList<AvailableSerialDto>>> AvailableSerials(
        [FromQuery] int itemId, [FromQuery] int warehouseId, [FromQuery] string? q, [FromQuery] int take = 200, CancellationToken ct = default)
        => Ok(await _tracking.GetAvailableSerialsAsync(itemId, warehouseId, q, take, ct));
    /// <summary>Issuable stock per batch with expiry, soonest expiry first.</summary>
    [HttpGet("batches/available")]
    [ProducesResponseType(typeof(IReadOnlyList<AvailableBatchDto>), StatusCodes.Status200OK)]
    public async Task<ActionResult<IReadOnlyList<AvailableBatchDto>>> AvailableBatches(
        [FromQuery] int itemId, [FromQuery] int warehouseId, CancellationToken ct)
        => Ok(await _tracking.GetAvailableBatchesAsync(itemId, warehouseId, ct));
    /// <summary>The FEFO pick posting would make for <c>qty</c> when no batch is chosen.</summary>
    [HttpGet("batches/suggest")]
    [ProducesResponseType(typeof(IReadOnlyList<BatchSuggestionDto>), StatusCodes.Status200OK)]
    public async Task<ActionResult<IReadOnlyList<BatchSuggestionDto>>> SuggestBatches(
        [FromQuery] int itemId, [FromQuery] int warehouseId, [FromQuery] decimal qty, CancellationToken ct)
        => Ok(await _tracking.SuggestBatchesAsync(itemId, warehouseId, qty, ct));
 }
@@ -65,15 +65,4 @@ public sealed class VendorsController : ApiControllerBase
        await _vendors.SetStatusAsync(vendorId, request.Status, ct);
        return NoContent();
    }
    [HttpDelete("{vendorId:int}")]
    [Authorize(Policy = NavPolicies.Prefix + "vendors" + NavPolicies.ActionSeparator + NavPolicies.DeleteAction)]
    [ProducesResponseType(StatusCodes.Status204NoContent)]
    [ProducesResponseType(StatusCodes.Status404NotFound)]
    [ProducesResponseType(StatusCodes.Status409Conflict)]
    public async Task<IActionResult> Delete(int vendorId, CancellationToken ct)
    {
        await _vendors.DeleteAsync(vendorId, ct);
        return NoContent();
    }
 }
@@ -1,30 +0,0 @@
 using ERPCore.Domain.Enums;
 using ERPCore.Dtos.Common;
 using ERPCore.Dtos.Stock;
 using ERPCore.Infra.Auth;
 using ERPCore.Services.Interfaces;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 namespace ERPCore.Controllers;
 /// <summary>
 /// Customer warranty register (docs/ITEM_TRACKING_PLAN.md Phase 5). Warranties are created by
 /// posting a sale, never directly — this controller only reads.
 /// </summary>
 [Route("api/v1/warranties")]
 [Authorize(Policy = NavPolicies.Prefix + "sales")]
 public sealed class WarrantiesController : ApiControllerBase
 {
    private readonly IItemTrackingService _tracking;
    public WarrantiesController(IItemTrackingService tracking) => _tracking = tracking;
    [HttpGet]
    [ProducesResponseType(typeof(PagedResponse<WarrantyRegistrationDto>), StatusCodes.Status200OK)]
    public async Task<ActionResult<PagedResponse<WarrantyRegistrationDto>>> List(
        [FromQuery] int? customerId, [FromQuery] int? itemId, [FromQuery] string? serialNo,
        [FromQuery] WarrantyStatus? status, [FromQuery] int? expiringWithinDays, [FromQuery] bool? expired,
        [FromQuery] PageQuery query, CancellationToken ct)
        => Ok(await _tracking.ListWarrantiesAsync(query, customerId, itemId, serialNo, status, expiringWithinDays, expired, ct));
 }
@@ -1,44 +0,0 @@
 using ERPCore.Domain.Enums;
 using ERPCore.Dtos.Items;
 using ERPCore.Infra.Auth;
 using ERPCore.Services.Interfaces;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 namespace ERPCore.Controllers;
 /// <summary>Custom warranty period master — managed under Products like Item Variants.</summary>
 [Route("api/v1/warranty-periods")]
 [Authorize(Policy = NavPolicies.Prefix + "products")]
 public sealed class WarrantyPeriodsController : ApiControllerBase
 {
    private readonly IWarrantyPeriodService _periods;
    public WarrantyPeriodsController(IWarrantyPeriodService periods) => _periods = periods;
    /// <summary>Custom periods only (defaults are fixed); filter <c>status=Active</c> for selectable rows.</summary>
    [HttpGet]
    [ProducesResponseType(typeof(List<WarrantyPeriodDto>), StatusCodes.Status200OK)]
    public async Task<ActionResult<List<WarrantyPeriodDto>>> List([FromQuery] EntityStatus? status, CancellationToken ct)
        => Ok(await _periods.ListAsync(status, ct));
    [HttpPost]
    [ProducesResponseType(typeof(WarrantyPeriodDto), StatusCodes.Status201Created)]
    [ProducesResponseType(StatusCodes.Status409Conflict)]
    [ProducesResponseType(StatusCodes.Status422UnprocessableEntity)]
    public async Task<ActionResult<WarrantyPeriodDto>> Create([FromBody] CreateWarrantyPeriodRequest request, CancellationToken ct)
    {
        var result = await _periods.CreateAsync(request.Months!.Value, ct);
        return Created($"/api/v1/warranty-periods/{result.WarrantyPeriodId}", result);
    }
    /// <summary>Deactivate/reactivate. Never hard-deleted (FR-MD-08).</summary>
    [HttpPatch("{warrantyPeriodId:int}/status")]
    [ProducesResponseType(StatusCodes.Status204NoContent)]
    [ProducesResponseType(StatusCodes.Status404NotFound)]
    public async Task<IActionResult> SetStatus(int warrantyPeriodId, [FromBody] UpdateWarrantyPeriodStatusRequest request, CancellationToken ct)
    {
        await _periods.SetStatusAsync(warrantyPeriodId, request.Status, ct);
        return NoContent();
    }
 }
@@ -26,13 +26,4 @@ public static class DocumentTypes
    /// <summary>Cashier day-end close-out (Sales) — <c>DEND-2026-00001</c>.</summary>
    public const string SalesDayEnd = "DEND";
    /// <summary>Business expense bill (Accounts) — <c>EXP-BR-001-2026-00001</c>.</summary>
    public const string Expense = "EXP";
    /// <summary>Till cash deposited to a bank account (Accounts) — <c>BD-BR-001-2026-00001</c>.</summary>
    public const string BankDeposit = "BD";
    /// <summary>Selling-price change request (Products) — <c>PADJ-2026-00001</c>.</summary>
    public const string PriceAdjustment = "PADJ";
 }
@@ -1,55 +0,0 @@
 using ERPCore.Domain.Enums;
 namespace ERPCore.Domain.Entities;
 /// <summary>
 /// Till cash taken to the bank (docs/BANK_DEPOSIT_MODULE_PLAN.md §4). Saving it posts a GL entry
 /// (Debit the bank account / Credit the cash account) and lowers the branch's cash in hand for
 /// <see cref="BusinessDate"/>. There is no draft: a wrong deposit is cancelled (the entry is
 /// reversed) and entered again. GL accounts have no local FK, so the account details are snapshots.
 /// </summary>
 public class BankDeposit
 {
    public int BankDepositId { get; set; }
    public string DocNo { get; set; } = string.Empty;
    public int BranchId { get; set; }
    public Branch? Branch { get; set; }
    /// <summary>The day whose cash is deposited — cash in hand and the day-end report group by this.</summary>
    public DateOnly BusinessDate { get; set; }
    /// <summary>The day the bank received it; the GL entry date.</summary>
    public DateOnly DepositDate { get; set; }
    public decimal Amount { get; set; }
    public long FromGlCashAccountId { get; set; }
    public string FromCashAccountCode { get; set; } = string.Empty;
    public string FromCashAccountName { get; set; } = string.Empty;
    public long ToGlBankAccountId { get; set; }
    public string ToBankAccountCode { get; set; } = string.Empty;
    public string ToBankAccountName { get; set; } = string.Empty;
    public string? ToBankName { get; set; }
    public string? ToAccountNumber { get; set; }
    public string? DepositSlipNo { get; set; }
    public string? DepositedBy { get; set; }
    public string? Remarks { get; set; }
    public BankDepositStatus Status { get; set; } = BankDepositStatus.Posted;
    public string? GlJournalNo { get; set; }
    public DateTime? GlPostedAt { get; set; }
    public string? GlReversalJournalNo { get; set; }
    public string? CancelReason { get; set; }
    public int? CancelledBy { get; set; }
    public DateTime? CancelledAt { get; set; }
    public int CreatedBy { get; set; }
    public User? Creator { get; set; }
    public DateTime CreatedAt { get; set; }
    public uint RowVersion { get; set; }
 }
@@ -9,18 +9,6 @@ namespace ERPCore.Domain.Entities;
 /// </summary>
 public class Branch
 {
    /// <summary>
    /// Code of the deployment's default branch. Every branch-scoped entity has a
    /// non-nullable <c>BranchId</c> with a Restrict FK, so this row must exist before any
    /// of them can be written — see <c>DataSeeder.EnsureDefaultBranchAsync</c>, which
    /// creates it at startup, and <c>BranchConfigService.ResolveDefaultBranchIdAsync</c>,
    /// which is the lazy runtime fallback.
    /// </summary>
    public const string DefaultCode = "BR-000";
    /// <summary>Display name paired with <see cref="DefaultCode"/>.</summary>
    public const string DefaultName = "Main Branch";
    public int BranchId { get; set; }
    /// <summary>Server-generated on create ("BR-001", "BR-002", ...) — never accepted from the client.</summary>
@@ -23,6 +23,12 @@ public class BranchConfig
    /// single-branch already).</summary>
    public bool WarehouseBranchingEnabled { get; set; } = true;
    /// <summary>Independent sub-toggle for Purchase Orders. On: each PO belongs to one branch,
    /// non-admins only see their own branch's POs, and line warehouses must be in that branch.
    /// Off: POs form one shared pool across branches (kept on the default branch, visible to
    /// everyone, any warehouse allowed). Meaningless when <see cref="BranchingEnabled"/> is off.</summary>
    public bool PurchaseOrderBranchingEnabled { get; set; } = true;
    public DateTime? UpdatedAt { get; set; }
    public int? UpdatedBy { get; set; }
@@ -25,14 +25,9 @@ public class BundleSale
    public decimal DiscountTotal { get; set; }
    public decimal TaxTotal { get; set; }
    public decimal GrandTotal { get; set; }
    /// <summary>How the (always fully paid) <see cref="GrandTotal"/> was tendered:
    /// <c>CashAmount + CardAmount == GrandTotal</c>. Backfilled as all cash.</summary>
    public decimal CashAmount { get; set; }
    public decimal CardAmount { get; set; }
    public DateTime CreatedAt { get; set; }
    public DateTime? UpdatedAt { get; set; }
-    public uint RowVersion { get; set; }
+    public int ConcurrencyStamp { get; set; }
    /// <summary>Set once this bundle's business date is closed by <see cref="SalesDayEnd"/> — a
    /// closed bundle sale is frozen (no further edits). Same role as <see cref="SalesSlip.DayEndId"/>;
@@ -11,7 +11,7 @@ public class BundleSaleTemplate
    public EntityStatus Status { get; set; } = EntityStatus.Active;
    public DateTime CreatedAt { get; set; }
    public DateTime? UpdatedAt { get; set; }
-    public uint RowVersion { get; set; }
+    public int ConcurrencyStamp { get; set; }
    public ICollection<BundleSaleTemplateLine> Lines { get; set; } = new List<BundleSaleTemplateLine>();
 }
@@ -1,48 +0,0 @@
 using ERPCore.Domain.Enums;
 namespace ERPCore.Domain.Entities;
 /// <summary>
 /// One approval decision on a document (docs/DUAL_APPROVAL_PLAN.md §4.1) — a row per decision, so
 /// the full trail survives. Polymorphic like the stock ledger: <see cref="DocType"/> +
 /// <see cref="DocId"/>, no FK. Doc types: <c>ADJ</c> (stock adjustment), <c>PADJ</c> (price adjustment).
 /// </summary>
 public class DocumentApproval
 {
    public int DocumentApprovalId { get; set; }
    public string DocType { get; set; } = string.Empty;
    public int DocId { get; set; }
    /// <summary>1 or 2.</summary>
    public int Level { get; set; }
    public ApprovalDecision Decision { get; set; }
    public int DecidedBy { get; set; }
    public User? Decider { get; set; }
    public DateTime DecidedAt { get; set; }
    public string? Comment { get; set; }
 }
 /// <summary>
 /// Approval rules (docs/DUAL_APPROVAL_PLAN.md §7). Singleton row, edited under Settings → Approvals.
 /// Levels: 0 = no approval (applies on create), 1 = one approver, 2 = two different approvers.
 /// </summary>
 public class ApprovalConfig
 {
    public const int SingletonId = 1;
    public int ApprovalConfigId { get; set; }
    public int StockAdjustmentLevels { get; set; } = 2;
    /// <summary>With 2 levels: an adjustment whose stock value is below this needs only one approval. 0 = always two.</summary>
    public decimal StockAdjustmentLevel2ThresholdValue { get; set; }
    public int PriceAdjustmentLevels { get; set; } = 2;
    /// <summary>With 2 levels: a change smaller than this percent (largest across its lines) needs only one approval. 0 = always two.</summary>
    public decimal PriceAdjustmentLevel2ThresholdPercent { get; set; }
    /// <summary>Comma-separated role codes allowed to give the second approval; empty = anyone with the Approve action.</summary>
    public string? Level2RoleCodes { get; set; }
    public DateTime? UpdatedAt { get; set; }
    public int? UpdatedBy { get; set; }
    public uint RowVersion { get; set; }
 }
@@ -1,92 +0,0 @@
 using ERPCore.Domain.Enums;
 namespace ERPCore.Domain.Entities;
 /// <summary>
 /// One business expense bill (electricity, rent, …) outside procurement. Draft is editable;
 /// Post accrues it to GL (Debit the title's expense account / Credit Accrued Expenses);
 /// payments then settle the accrual in one or more installments (see
 /// ExpensePaymentService). Model: docs/EXPENSE_MODULE_PLAN.md §3.3.
 /// </summary>
 public class Expense
 {
    public int ExpenseId { get; set; }
    public string DocNo { get; set; } = string.Empty;
    public int BranchId { get; set; }
    public Branch? Branch { get; set; }
    public DateOnly ExpenseDate { get; set; }
    public DateOnly? DueDate { get; set; }
    public int ExpenseCategoryId { get; set; }
    public ExpenseCategory? Category { get; set; }
    public int ExpenseTitleId { get; set; }
    public ExpenseTitle? Title { get; set; }
    public string? Payee { get; set; }
    public int? VendorId { get; set; }
    public Vendor? Vendor { get; set; }
    public string? BillReference { get; set; }
    public string? Description { get; set; }
    /// <summary>Optional month the bill covers, as <c>yyyy-MM</c> (e.g. September's electricity).</summary>
    public string? PeriodMonth { get; set; }
    public decimal Amount { get; set; }
    public decimal PaidAmount { get; set; }
    public decimal BalanceAmount { get; set; }
    public ExpenseStatus Status { get; set; } = ExpenseStatus.Draft;
    public ExpensePaymentStatus PaymentStatus { get; set; } = ExpensePaymentStatus.Unpaid;
    /// <summary>Snapshot of the title's GL expense account at post time.</summary>
    public string? GlExpenseAccountCode { get; set; }
    /// <summary>Journal number of the accrual entry posted on Post.</summary>
    public string? GlJournalNo { get; set; }
    public DateTime? GlPostedAt { get; set; }
    /// <summary>Journal number of the reversing entry posted on Cancel (Posted expenses only).</summary>
    public string? GlReversalJournalNo { get; set; }
    public string? CancelReason { get; set; }
    public int CreatedBy { get; set; }
    public User? Creator { get; set; }
    public DateTime CreatedAt { get; set; }
    public DateTime? UpdatedAt { get; set; }
    public uint RowVersion { get; set; }
    public ICollection<ExpensePayment> Payments { get; set; } = new List<ExpensePayment>();
 }
 /// <summary>
 /// A payment against a Posted expense's balance (installments allowed). Every line of one
 /// payment submission shares the single GL journal entry that submission posted (Debit
 /// Accrued Expenses / Credit each selected cash-or-bank account). Mirrors
 /// <see cref="PurchaseInvoicePayment"/>.
 /// </summary>
 public class ExpensePayment
 {
    public int ExpensePaymentId { get; set; }
    public int ExpenseId { get; set; }
    public Expense? Expense { get; set; }
    public decimal Amount { get; set; }
    public DateTime PaymentDate { get; set; }
    public ExpensePaymentMethod PaymentMethod { get; set; }
    /// <summary>GL's numeric id for the bank/cash account the payment was made from.</summary>
    public long GlBankAccountId { get; set; }
    /// <summary>Snapshot of the account's display name at payment time (GL account lists have no local FK).</summary>
    public string BankAccountName { get; set; } = string.Empty;
    public string? ChequeNo { get; set; }
    public string? Reference { get; set; }
    public string? GlJournalNo { get; set; }
    public int CreatedBy { get; set; }
    public User? Creator { get; set; }
    public DateTime CreatedAt { get; set; }
 }
@@ -1,48 +0,0 @@
 using ERPCore.Domain.Enums;
 namespace ERPCore.Domain.Entities;
 /// <summary>
 /// Top-level expense grouping (Utility, Rental, Salaries, Other). The four seeded rows are
 /// <see cref="IsSystem"/> — they can be deactivated but not renamed; admins can add more.
 /// Each category owns its <see cref="ExpenseTitle"/>s. Model: docs/EXPENSE_MODULE_PLAN.md §3.1.
 /// </summary>
 public class ExpenseCategory
 {
    public int ExpenseCategoryId { get; set; }
    public string Code { get; set; } = string.Empty;
    public string Name { get; set; } = string.Empty;
    public bool IsSystem { get; set; }
    public EntityStatus Status { get; set; } = EntityStatus.Active;
    public int SortOrder { get; set; }
    public DateTime CreatedAt { get; set; }
    public DateTime? UpdatedAt { get; set; }
    public uint RowVersion { get; set; }
    public ICollection<ExpenseTitle> Titles { get; set; } = new List<ExpenseTitle>();
 }
 /// <summary>
 /// A specific expense under a category (Utility → Electricity, Water, …). Carries the GL
 /// expense account debited when an expense with this title is posted — snapshotted onto the
 /// expense at post time, so changing it later does not touch already-posted expenses.
 /// Model: docs/EXPENSE_MODULE_PLAN.md §3.2.
 /// </summary>
 public class ExpenseTitle
 {
    public int ExpenseTitleId { get; set; }
    public int ExpenseCategoryId { get; set; }
    public ExpenseCategory? Category { get; set; }
    public string Name { get; set; } = string.Empty;
    public string GlExpenseAccountCode { get; set; } = string.Empty;
    public bool IsSystem { get; set; }
    public EntityStatus Status { get; set; } = EntityStatus.Active;
    public int SortOrder { get; set; }
    public DateTime CreatedAt { get; set; }
    public DateTime? UpdatedAt { get; set; }
    public uint RowVersion { get; set; }
 }
@@ -1,71 +0,0 @@
 namespace ERPCore.Domain.Entities;
 /// <summary>
 /// Role → GL account code mapping — a singleton row, same shape as <see cref="GrnConfig"/>.
 /// <para>
 /// This is master data, not deployment config. It used to live in <c>appsettings.json</c> as
 /// per-module <c>Gl*Code</c> keys, which meant (a) only a redeploy could correct a mapping, and
 /// (b) nothing checked the codes existed in GL until something tried to post. Held here it is
 /// validated against GL's live chart of accounts on every save, so an unknown or non-postable
 /// account cannot be stored in the first place — see <c>GlAccountConfigService.UpdateAsync</c>.
 /// </para>
 /// <para>
 /// Codes are nullable: a fresh install has nothing mapped, and a posting flow that needs an
 /// unmapped role fails with <c>GL_ACCOUNT_NOT_CONFIGURED</c> naming that role. Width matches
 /// GL's own <c>accounts.account_code varchar(20)</c>.
 /// </para>
 /// </summary>
 public class GlAccountConfig
 {
    /// <summary>Always 1 - the singleton row's id.</summary>
    public const int SingletonId = 1;
    /// <summary>Matches GL's <c>accounts.account_code</c> column width.</summary>
    public const int CodeMaxLength = 20;
    public int ConfigId { get; set; }
    /// <summary>Stock on hand (was <c>Grn|Adjustment|SalesDayEnd|Fifo:GlInventoryAccountCode</c>).</summary>
    public string? InventoryAccountCode { get; set; }
    /// <summary>Recoverable input VAT (was <c>Grn:GlVatRecoverableAccountCode</c>).</summary>
    public string? VatRecoverableAccountCode { get; set; }
    /// <summary>Trade debtors (was <c>SalesDayEnd|SalesInvoice:GlAccountsReceivableCode</c>).</summary>
    public string? AccountsReceivableCode { get; set; }
    /// <summary>Goods received not invoiced (was <c>Grn|PurchaseInvoice|Fifo:GlClearingAccountCode</c>).</summary>
    public string? ClearingAccountCode { get; set; }
    /// <summary>Output tax payable (was <c>SalesDayEnd:GlTaxPayableAccountCode</c>).</summary>
    public string? TaxPayableAccountCode { get; set; }
    /// <summary>Trade creditors (was <c>PurchaseInvoice:GlAccountsPayableCode</c>).</summary>
    public string? AccountsPayableCode { get; set; }
    /// <summary>Sales revenue (was <c>SalesDayEnd:GlSalesRevenueAccountCode</c>).</summary>
    public string? SalesRevenueAccountCode { get; set; }
    /// <summary>Sales discount given (was <c>SalesDayEnd:GlSalesDiscountAccountCode</c>).</summary>
    public string? SalesDiscountAccountCode { get; set; }
    /// <summary>Inventory gain on adjustment/count (was <c>Adjustment:GlGainAccountCode</c>).</summary>
    public string? InventoryGainAccountCode { get; set; }
    /// <summary>Cost of goods sold (was <c>SalesDayEnd:GlCogsAccountCode</c>).</summary>
    public string? CogsAccountCode { get; set; }
    /// <summary>Inventory loss on adjustment/count (was <c>Adjustment:GlLossAccountCode</c>).</summary>
    public string? InventoryLossAccountCode { get; set; }
    /// <summary>Cash takings at day-end (was <c>SalesDayEnd:GlCashAccountCode</c>).</summary>
    public string? CashAccountCode { get; set; }
    public DateTime? UpdatedAt { get; set; }
    public int? UpdatedBy { get; set; }
    public User? UpdatedByUser { get; set; }
    /// <summary>Optimistic concurrency token (ETag source); bumped by ErpDbContext.BumpRowVersions.</summary>
    public uint RowVersion { get; set; }
 }
@@ -1,41 +0,0 @@
 namespace ERPCore.Domain.Entities;
 /// <summary>
 /// GRN (goods receipt) configuration — a singleton row, same shape as <see cref="SalesConfig"/>.
 /// Controls which warehouse goods are received into.
 /// </summary>
 public class GrnConfig
 {
    /// <summary>Always 1 - the singleton row's id.</summary>
    public const int SingletonId = 1;
    public int ConfigId { get; set; }
    /// <summary>When on (default) and no <see cref="DefaultWarehouseId"/> is saved, New GRN shows
    /// a Warehouse picker. When off, a default must be saved.</summary>
    public bool AllowWarehouseSelection { get; set; } = true;
    /// <summary>Default receiving warehouse. Whenever set, New GRN shows only this warehouse (locked)
    /// and every GRN is forced onto it server-side (see GrnConfigService.GetForcedWarehouseIdAsync).
    /// Required while <see cref="AllowWarehouseSelection"/> is off; clearing it brings the picker back.</summary>
    public int? DefaultWarehouseId { get; set; }
    public Warehouse? DefaultWarehouse { get; set; }
    /// <summary>When on (default), GRN lines may carry a discount % (the New GRN "Disc %" column and
    /// header rate); when off, they are hidden and a discount above zero is rejected server-side
    /// (see GrnService.CreateAsync).</summary>
    public bool AllowDiscounts { get; set; } = true;
    /// <summary>When on (default), GRN lines carry VAT (entered, or the item's tax rate when left
    /// empty); when off, the VAT columns are hidden, every line is received at 0% VAT, and a VAT
    /// above zero is rejected server-side (see GrnService.CreateAsync).</summary>
    public bool AllowVat { get; set; } = true;
    public DateTime? UpdatedAt { get; set; }
    public int? UpdatedBy { get; set; }
    public User? UpdatedByUser { get; set; }
    /// <summary>PostgreSQL xmin-backed optimistic concurrency token (ETag source).</summary>
    public uint RowVersion { get; set; }
 }
@@ -65,12 +65,4 @@ public class GrnLine
    /// Empty for a non-warranty item.
    /// </summary>
    public ICollection<GrnLineWarrantyNumber> WarrantyNumbers { get; set; } = new List<GrnLineWarrantyNumber>();
    /// <summary>
    /// One row per received unit when <see cref="Item.TrackingMode"/> is
    /// <see cref="TrackingMode.Serial"/> — count must equal <see cref="Qty"/>. For a serial item
    /// under warranty the serial is the warranty identity, so it carries no
    /// <see cref="WarrantyNumbers"/>. Empty otherwise.
    /// </summary>
    public ICollection<GrnLineSerial> Serials { get; set; } = new List<GrnLineSerial>();
 }
@@ -1,22 +0,0 @@
 namespace ERPCore.Domain.Entities;
 /// <summary>
 /// A serial number captured on a Draft GRN line for a serial-tracked item
 /// (<see cref="Item.TrackingMode"/> = <see cref="Enums.TrackingMode.Serial"/>). The line must
 /// carry exactly <see cref="GrnLine.Qty"/> of these. The draft holds the numbers only — the
 /// <see cref="Serial"/> rows (and their qty-1 FIFO layers) are created when the GRN is
 /// confirmed, so a draft that is never confirmed reserves nothing (docs/ITEM_TRACKING_PLAN.md Phase 2).
 /// </summary>
 public class GrnLineSerial
 {
    public int GrnLineSerialId { get; set; }
    public int GrnLineId { get; set; }
    public GrnLine? GrnLine { get; set; }
    public string SerialNo { get; set; } = string.Empty;
    /// <summary>Set on confirm — the <see cref="Serial"/> created for this number.</summary>
    public int? SerialId { get; set; }
    public Serial? Serial { get; set; }
 }
@@ -1,27 +0,0 @@
 namespace ERPCore.Domain.Entities;
 /// <summary>
 /// A product photo attached to an item. Like <see cref="EmployeeDocument"/>, the file lives
 /// behind <see cref="Infra.Storage.IFileStorageService"/> under a server-generated name and is
 /// only reachable through the authenticated items API — never a static path. Only uploadable
 /// while <see cref="ProductConfig.ItemImagesEnabled"/> is on; existing images stay readable
 /// after the flag is switched off (reads are never gated).
 /// </summary>
 public class ItemImage
 {
    public int ItemImageId { get; set; }
    public int ItemId { get; set; }
    public Item? Item { get; set; }
    public string OriginalFileName { get; set; } = string.Empty;
    public string StoredFileName { get; set; } = string.Empty;
    public string RelativePath { get; set; } = string.Empty;
    public string ContentType { get; set; } = string.Empty;
    public long SizeBytes { get; set; }
    /// <summary>Display order; the lowest is the item's main image.</summary>
    public int SortOrder { get; set; }
    public int UploadedBy { get; set; }
    public DateTime UploadedAt { get; set; }
 }
@@ -1,78 +0,0 @@
 using ERPCore.Domain.Enums;
 namespace ERPCore.Domain.Entities;
 /// <summary>
 /// A request to change items' selling prices (docs/DUAL_APPROVAL_PLAN.md §6). Nothing changes on the
 /// items until it is fully approved; then each line's new prices are written to its item and an
 /// <see cref="ItemPriceHistory"/> row is kept. <see cref="CreatedBy"/> is the requester.
 /// </summary>
 public class PriceAdjustment
 {
    public int PriceAdjustmentId { get; set; }
    public string DocNo { get; set; } = string.Empty;
    public string Reason { get; set; } = string.Empty;
    public PriceAdjustmentStatus Status { get; set; } = PriceAdjustmentStatus.PendingApproval;
    public int RequiredApprovals { get; set; }
    public int CreatedBy { get; set; }
    public User? Creator { get; set; }
    public DateTime CreatedAt { get; set; }
    public int? ApprovedLevel1By { get; set; }
    public DateTime? ApprovedLevel1At { get; set; }
    public int? ApprovedLevel2By { get; set; }
    public DateTime? ApprovedLevel2At { get; set; }
    public int? RejectedBy { get; set; }
    public DateTime? RejectedAt { get; set; }
    public string? RejectReason { get; set; }
    public DateTime? CancelledAt { get; set; }
    /// <summary>When the new prices were written to the items.</summary>
    public DateTime? AppliedAt { get; set; }
    public uint RowVersion { get; set; }
    public ICollection<PriceAdjustmentLine> Lines { get; set; } = new List<PriceAdjustmentLine>();
 }
 /// <summary>One item's change. The Old* values are the item's prices when the request was made —
 /// approval fails if the item has been repriced since (stale request).</summary>
 public class PriceAdjustmentLine
 {
    public int PriceAdjustmentLineId { get; set; }
    public int PriceAdjustmentId { get; set; }
    public PriceAdjustment? PriceAdjustment { get; set; }
    public int ItemId { get; set; }
    public Item? Item { get; set; }
    public decimal? OldMinPrice { get; set; }
    public decimal? OldMaxPrice { get; set; }
    public decimal? OldFlatPrice { get; set; }
    public decimal? NewMinPrice { get; set; }
    public decimal? NewMaxPrice { get; set; }
    public decimal? NewFlatPrice { get; set; }
 }
 /// <summary>An applied selling-price change: what it was, what it became, and who approved it.</summary>
 public class ItemPriceHistory
 {
    public int ItemPriceHistoryId { get; set; }
    public int ItemId { get; set; }
    public Item? Item { get; set; }
    public int? PriceAdjustmentId { get; set; }
    public PriceAdjustment? PriceAdjustment { get; set; }
    public decimal? OldMinPrice { get; set; }
    public decimal? OldMaxPrice { get; set; }
    public decimal? OldFlatPrice { get; set; }
    public decimal? NewMinPrice { get; set; }
    public decimal? NewMaxPrice { get; set; }
    public decimal? NewFlatPrice { get; set; }
    public int RequestedBy { get; set; }
    public int? ApprovedLevel1By { get; set; }
    public int? ApprovedLevel2By { get; set; }
    public DateTime AppliedAt { get; set; }
 }
@@ -31,26 +31,6 @@ public class ProductConfig
    public bool BatchListsEnabled { get; set; } = true;
    public bool WarrantyPeriodsEnabled { get; set; } = true;
    /// <summary>
    /// Lets the item create screen add a new item variant (item type) on the spot, instead
    /// of only picking from the Item Variants master. Advisory like <see cref="ItemTypesEnabled"/>
    /// - it gates a UI shortcut; the Item Variants master itself stays available either way.
    /// </summary>
    public bool CustomVariantsEnabled { get; set; }
    /// <summary>
    /// Allows photos to be uploaded to items (<see cref="ItemImage"/>). Enforced on upload
    /// (<c>CONFIG_DISABLED</c>); images added earlier stay viewable when switched off.
    /// </summary>
    public bool ItemImagesEnabled { get; set; }
    /// <summary>
    /// Lets items use the active <see cref="WarrantyPeriod"/> master rows alongside the default
    /// <see cref="Enums.WarrantyPeriods.AllowedMonths"/>. Enforced on item writes. The periods
    /// themselves are managed under Products, not here.
    /// </summary>
    public bool CustomWarrantyPeriodsEnabled { get; set; }
    public DateTime? UpdatedAt { get; set; }
    public int? UpdatedBy { get; set; }
@@ -1,61 +0,0 @@
 namespace ERPCore.Domain.Entities;
 /// <summary>
 /// Sales configuration — a singleton row (single-tenant, docs/00-CORE §1), same shape as
 /// <see cref="BranchConfig"/>. When <see cref="AllowCashCustomer"/> is on, sales documents may
 /// be raised against the generic "Cash Customer" (<see cref="CashCustomerId"/>) and the New Sale
 /// form defaults to it; when off, a real customer must be picked and the cash customer is
 /// rejected server-side (see SalesDomainService.ValidateSalesHeaderAsync).
 /// </summary>
 public class SalesConfig
 {
    /// <summary>Always 1 - the singleton row's id.</summary>
    public const int SingletonId = 1;
    public int ConfigId { get; set; }
    public bool AllowCashCustomer { get; set; }
    /// <summary>The Customer row used for cash (walk-in, unnamed) sales. Created on first
    /// enabling <see cref="AllowCashCustomer"/> and kept afterwards, so switching the option
    /// off and on again reuses the same customer (and its sales history).</summary>
    public int? CashCustomerId { get; set; }
    public Customer? CashCustomer { get; set; }
    /// <summary>When on, sales invoice lines may carry a free quantity (the New Sale "Free"
    /// column); when off, the column is hidden and a free qty above zero is rejected server-side
    /// (see SalesInvoiceService.BuildLinesAsync). Defaults on, matching the behaviour before
    /// this option existed.</summary>
    public bool AllowFreeItems { get; set; } = true;
    /// <summary>When on, sales invoice lines may carry a line discount (the New Sale "Disc %"
    /// column); when off, the column is hidden and a discount above zero is rejected server-side
    /// (see SalesInvoiceService.BuildLinesAsync). Defaults on, matching the behaviour before
    /// this option existed.</summary>
    public bool AllowDiscounts { get; set; } = true;
    /// <summary>When on, posting a sale (invoice, slip, bundle) may issue more than the stock on
    /// hand — the shortfall drives on-hand negative (see FifoCostingService.ConsumeAsync) and the
    /// pre-post check reports it as a warning only. When off (default), posting is blocked with
    /// STOCK_NEGATIVE_BLOCKED until stock covers every line.</summary>
    public bool AllowOverStockSale { get; set; }
    /// <summary>When on (default) and no <see cref="DefaultWarehouseId"/> is saved, New Sale shows
    /// a Warehouse picker. When off, a default must be saved.</summary>
    public bool AllowWarehouseSelection { get; set; } = true;
    /// <summary>Default sales warehouse. Whenever set, New Sale shows only this warehouse (locked)
    /// and every sales invoice (header and lines) is forced onto it server-side (see
    /// SalesDomainService.GetForcedSalesWarehouseIdAsync). Required while
    /// <see cref="AllowWarehouseSelection"/> is off; clearing it brings the picker back.</summary>
    public int? DefaultWarehouseId { get; set; }
    public Warehouse? DefaultWarehouse { get; set; }
    public DateTime? UpdatedAt { get; set; }
    public int? UpdatedBy { get; set; }
    public User? UpdatedByUser { get; set; }
    /// <summary>PostgreSQL xmin-backed optimistic concurrency token (ETag source).</summary>
    public uint RowVersion { get; set; }
 }
@@ -19,13 +19,6 @@ public class SalesInvoiceLine
    public int WarehouseId { get; set; }
    public Warehouse? Warehouse { get; set; }
    /// <summary>Pins the line to one batch; null lets posting pick batches FEFO.</summary>
    public int? BatchId { get; set; }
    public Batch? Batch { get; set; }
    /// <summary>Chosen serials for a serial-tracked item (one per unit of Qty + FreeQty).</summary>
    public ICollection<SalesInvoiceLineSerial> Serials { get; set; } = new List<SalesInvoiceLineSerial>();
    public decimal UnitPrice { get; set; }
    public decimal BaseCost { get; set; }
    public string PriceSource { get; set; } = string.Empty;
@@ -1,5 +1,3 @@
 using ERPCore.Domain.Enums;
 namespace ERPCore.Domain.Entities;
 /// <summary>
@@ -23,9 +21,6 @@ public class SalesInvoicePayment
    /// <summary>Snapshot of the account's display name at payment time (GL account lists have no local FK).</summary>
    public string BankAccountName { get; set; } = string.Empty;
    /// <summary>How the customer paid. Payments recorded before this existed were backfilled as Cash.</summary>
    public SalesPaymentMethod PaymentMethod { get; set; } = SalesPaymentMethod.Cash;
    public string? Reference { get; set; }
    /// <summary>Journal number of the real GL journal entry this payment posted.</summary>
@@ -1,35 +0,0 @@
 namespace ERPCore.Domain.Entities;
 /// <summary>
 /// What a posted sales line actually issued: one row per consumed FIFO segment, carrying the
 /// batch (FEFO-picked when the line named none) and, for serial items, the serial. The source
 /// line is referenced polymorphically (<see cref="SourceDocType"/> is a
 /// <see cref="Domain.DocumentTypes"/> value) — same convention as <see cref="StockLedger"/> —
 /// so invoices, slips and bundles share one table. Returns read it to restock into the same
 /// batch/serial (docs/ITEM_TRACKING_PLAN.md Phases 4 and 6).
 /// </summary>
 public class SalesLineAllocation
 {
    public int SalesLineAllocationId { get; set; }
    public string SourceDocType { get; set; } = string.Empty;
    public int SourceDocId { get; set; }
    public int SourceLineId { get; set; }
    public int ItemId { get; set; }
    public int WarehouseId { get; set; }
    public int? BatchId { get; set; }
    public Batch? Batch { get; set; }
    public int? SerialId { get; set; }
    public Serial? Serial { get; set; }
    public decimal Qty { get; set; }
    public decimal UnitCost { get; set; }
    /// <summary>Quantity of this allocation already taken back by sales returns.</summary>
    public decimal QtyReturned { get; set; }
    public DateTime CreatedAt { get; set; }
 }
@@ -1,29 +0,0 @@
 namespace ERPCore.Domain.Entities;
 /// <summary>
 /// A serial chosen on a Draft sales-invoice line for a serial-tracked item — one row per unit
 /// (count = Qty + FreeQty). Choosing does not reserve: posting re-checks each serial is still
 /// in stock and consumes exactly its layer (docs/ITEM_TRACKING_PLAN.md Phase 4, D4).
 /// </summary>
 public class SalesInvoiceLineSerial
 {
    public int SalesInvoiceLineSerialId { get; set; }
    public int SalesInvoiceLineId { get; set; }
    public SalesInvoiceLine? SalesInvoiceLine { get; set; }
    public int SerialId { get; set; }
    public Serial? Serial { get; set; }
 }
 /// <summary>Sales-slip counterpart of <see cref="SalesInvoiceLineSerial"/>.</summary>
 public class SalesSlipLineSerial
 {
    public int SalesSlipLineSerialId { get; set; }
    public int SalesSlipLineId { get; set; }
    public SalesSlipLine? SalesSlipLine { get; set; }
    public int SerialId { get; set; }
    public Serial? Serial { get; set; }
 }
@@ -2,9 +2,7 @@ namespace ERPCore.Domain.Entities;
 /// <summary>
 /// Sales-return line referencing the original sales invoice line for traceability.
-/// <see cref="Qty"/> is in base UOM. <see cref="BatchId"/> is the batch the goods are restocked
+/// <see cref="Qty"/> is in base UOM.
 /// into — the batch they were sold from (docs/ITEM_TRACKING_PLAN.md Phase 6); <see cref="Serials"/>
 /// lists the returned units of a serial-tracked item.
 /// </summary>
 public class SalesReturnLine
 {
@@ -20,21 +18,4 @@ public class SalesReturnLine
    public Item? Item { get; set; }
    public decimal Qty { get; set; }
    public int? BatchId { get; set; }
    public Batch? Batch { get; set; }
    public ICollection<SalesReturnLineSerial> Serials { get; set; } = new List<SalesReturnLineSerial>();
 }
 /// <summary>One serial taken back on a <see cref="SalesReturnLine"/>.</summary>
 public class SalesReturnLineSerial
 {
    public int SalesReturnLineSerialId { get; set; }
    public int ReturnLineId { get; set; }
    public SalesReturnLine? ReturnLine { get; set; }
    public int SerialId { get; set; }
    public Serial? Serial { get; set; }
 }
@@ -27,11 +27,6 @@ public class SalesSlip
    public decimal PaidAmount { get; set; }
    public decimal BalanceAmount { get; set; }
    /// <summary>How <see cref="PaidAmount"/> was tendered: <c>CashAmount + CardAmount == PaidAmount</c>.
    /// Slips from before the split existed were backfilled as all cash.</summary>
    public decimal CashAmount { get; set; }
    public decimal CardAmount { get; set; }
    /// <summary>Set once this slip's business date is closed by <see cref="SalesDayEnd"/> — a closed slip is frozen (no further edits).</summary>
    public int? DayEndId { get; set; }
    public SalesDayEnd? DayEnd { get; set; }
@@ -22,16 +22,9 @@ public class SalesSlipLine
    public int? BatchId { get; set; }
    public Batch? Batch { get; set; }
    /// <summary>
    /// Legacy single-serial pin, from before a line could carry several. Kept for old drafts and
    /// still set when exactly one serial is chosen; <see cref="Serials"/> is authoritative.
    /// </summary>
    public int? SerialId { get; set; }
    public Serial? Serial { get; set; }
    /// <summary>Chosen serials for a serial-tracked item (one per unit of Qty + FreeQty).</summary>
    public ICollection<SalesSlipLineSerial> Serials { get; set; } = new List<SalesSlipLineSerial>();
    public decimal UnitPrice { get; set; }
    public decimal BaseCost { get; set; }
    public string PriceSource { get; set; } = string.Empty;
@@ -1,13 +1,8 @@
 using ERPCore.Domain.Enums;
 namespace ERPCore.Domain.Entities;
 /// <summary>
 /// Serial number for a serial-tracked item across its lifecycle (FR-WH-04).
-/// Created when the GRN that received it is confirmed; each in-stock serial owns exactly one
+/// Model: docs/10 Part C.4.
 /// FIFO layer of qty 1 (<see cref="StockLayer.SerialId"/>), so issuing a serial consumes that
 /// layer. <see cref="WarehouseId"/>/<see cref="BinId"/> are its current location and are
 /// cleared once it leaves stock. Model: docs/10 Part C.4, docs/ITEM_TRACKING_PLAN.md Phase 1.
 /// </summary>
 public class Serial
 {
@@ -17,33 +12,8 @@ public class Serial
    public Item? Item { get; set; }
    public string SerialNo { get; set; } = string.Empty;
-    public SerialStatus Status { get; set; } = SerialStatus.InStock;
+    public string Status { get; set; } = "InStock";
    /// <summary>Optional scan code for barcode/RFID lookup (unique when set).</summary>
    public string? Barcode { get; set; }
    /// <summary>Current warehouse while in stock; null once sold/returned to vendor/scrapped.</summary>
    public int? WarehouseId { get; set; }
    public Warehouse? Warehouse { get; set; }
    public int? BinId { get; set; }
    public Bin? Bin { get; set; }
    /// <summary>The GRN line that received this unit (provenance); null for count/adjustment finds.</summary>
    public int? GrnLineId { get; set; }
    public GrnLine? GrnLine { get; set; }
    public DateTime? ReceivedAt { get; set; }
    /// <summary>
    /// Warranty coverage snapshotted from <see cref="Item.WarrantyPeriodMonths"/> at receipt
    /// (same rule as <see cref="GrnLineWarrantyNumber.WarrantyPeriodMonths"/>); null for a
    /// non-warranty item. The clock does not start here — it starts at sale
    /// (<see cref="WarrantyRegistration"/>).
    /// </summary>
    public int? WarrantyPeriodMonths { get; set; }
    public DateTime CreatedAt { get; set; }
    public DateTime? UpdatedAt { get; set; }
    public uint RowVersion { get; set; }
 }
@@ -1,46 +0,0 @@
 using ERPCore.Domain.Enums;
 namespace ERPCore.Domain.Entities;
 /// <summary>
 /// Append-only history of one serial: a row each time a document changes its status or
 /// location (receipt, sale, return, transfer, adjustment, count). <see cref="Status"/> and
 /// <see cref="WarehouseId"/> are the serial's state <em>after</em> the movement. The source
 /// document is referenced polymorphically, as on <see cref="StockLedger"/>. This is where serial
 /// history is read from — the stock ledger keeps one row per document line, not per unit
 /// (docs/ITEM_TRACKING_PLAN.md Phases 2 and 9).
 /// </summary>
 public class SerialMovement
 {
    public int SerialMovementId { get; set; }
    public int SerialId { get; set; }
    public Serial? Serial { get; set; }
    public string SourceDocType { get; set; } = string.Empty;
    public int SourceDocId { get; set; }
    public SerialStatus Status { get; set; }
    public int? FromWarehouseId { get; set; }
    public int? WarehouseId { get; set; }
    public int UserId { get; set; }
    public DateTime CreatedAt { get; set; }
    /// <summary>
    /// Records <paramref name="serial"/>'s current state — call after updating it. Linked by
    /// navigation, so it works for a serial inserted in the same save.
    /// </summary>
    public static SerialMovement Of(Serial serial, int? fromWarehouseId, string sourceDocType, int sourceDocId, int userId, DateTime at) => new()
    {
        Serial = serial,
        SerialId = serial.SerialId,
        SourceDocType = sourceDocType,
        SourceDocId = sourceDocId,
        Status = serial.Status,
        FromWarehouseId = fromWarehouseId,
        WarehouseId = serial.WarehouseId,
        UserId = userId,
        CreatedAt = at
    };
 }
@@ -37,20 +37,5 @@ public class StockAdjustment
    public string? GlJournalNo { get; set; }
    public DateTime? GlPostedAt { get; set; }
    // --- Approval (docs/DUAL_APPROVAL_PLAN.md §5). CreatedBy is the requester. ---
    /// <summary>Approvals this request needs (0 = posted on create, 1 or 2), fixed when it is made.</summary>
    public int RequiredApprovals { get; set; }
    public int? ApprovedLevel1By { get; set; }
    public DateTime? ApprovedLevel1At { get; set; }
    public int? ApprovedLevel2By { get; set; }
    public DateTime? ApprovedLevel2At { get; set; }
    public int? RejectedBy { get; set; }
    public DateTime? RejectedAt { get; set; }
    public string? RejectReason { get; set; }
    public DateTime? CancelledAt { get; set; }
    /// <summary>When stock actually moved — the ledger and GL use this, not <see cref="CreatedAt"/>.</summary>
    public DateTime? PostedAt { get; set; }
    public ICollection<StockAdjustmentLine> Lines { get; set; } = new List<StockAdjustmentLine>();
 }
@@ -18,15 +18,6 @@ public class StockAdjustmentLine
    public int? BinId { get; set; }
    public int? BatchId { get; set; }
    public int? SerialId { get; set; }
    public Serial? Serial { get; set; }
    public decimal QtyDelta { get; set; }
    /// <summary>
    /// The serials named on the request, kept until it posts (JSON arrays): outbound serial ids
    /// to write off, inbound serial numbers found. Re-validated at posting, because a pending
    /// request moves nothing and the serials may have moved in the meantime.
    /// </summary>
    public string? RequestedSerialIds { get; set; }
    public string? RequestedSerialNos { get; set; }
 }
@@ -32,27 +32,4 @@ public class StockTransferLine
    /// <summary>Quantity already received at the destination (partial-receive support).</summary>
    public decimal QtyReceived { get; set; }
    /// <summary>The units moved, for a serial-tracked item (one per unit of <see cref="Qty"/>).</summary>
    public ICollection<StockTransferLineSerial> Serials { get; set; } = new List<StockTransferLineSerial>();
 }
 /// <summary>
 /// One serial on a transfer line. <see cref="UnitCost"/>/<see cref="BatchId"/> are captured from
 /// its own source layer at dispatch, so the destination layer is recreated exactly;
 /// <see cref="ReceivedAt"/> is set when it arrives (partial receive names which serials).
 /// </summary>
 public class StockTransferLineSerial
 {
    public int StockTransferLineSerialId { get; set; }
    public int TransferLineId { get; set; }
    public StockTransferLine? TransferLine { get; set; }
    public int SerialId { get; set; }
    public Serial? Serial { get; set; }
    public int? BatchId { get; set; }
    public decimal? UnitCost { get; set; }
    public DateTime? ReceivedAt { get; set; }
 }
@@ -15,12 +15,6 @@ public class User
    /// <summary>Seeded fallback actor for unauthenticated/system operations.</summary>
    public const int SystemUserId = 1;
    /// <summary>
    /// Username prefix of a permanently deleted login whose row is kept only because history
    /// (audit log, documents) still references it. Such rows are hidden from user management.
    /// </summary>
    public const string DeletedUsernamePrefix = "deleted-user-";
    public int UserId { get; set; }
    public string Username { get; set; } = string.Empty;
    public string DisplayName { get; set; } = string.Empty;
@@ -37,6 +31,14 @@ public class User
    /// </summary>
    public string? Email { get; set; }
    /// <summary>
    /// Set when an admin creates the account with an issued (temporary) password
    /// (<c>UserManagementService.CreateAsync</c>); surfaced via <c>GET /auth/me</c> so the
    /// frontend forces a password change on first login. Cleared by
    /// <c>POST /auth/change-password</c>.
    /// </summary>
    public bool MustChangePassword { get; set; }
    /// <summary>Local shadow <see cref="Role"/> assignment; null until an admin assigns one.</summary>
    public int? RoleId { get; set; }
    public Role? Role { get; set; }
@@ -14,6 +14,8 @@ public class Vendor
    public string Name { get; set; } = string.Empty;
    public string? Terms { get; set; }
    public string? TaxReg { get; set; }
    public string? Address { get; set; }
    public string? Phone { get; set; }
    public string Currency { get; set; } = "LKR";
    public EntityStatus Status { get; set; } = EntityStatus.Active;
@@ -1,23 +0,0 @@
 using ERPCore.Domain.Enums;
 namespace ERPCore.Domain.Entities;
 /// <summary>
 /// Custom warranty period master — a coverage length offered to items alongside the fixed
 /// defaults in <see cref="WarrantyPeriods.AllowedMonths"/>, while
 /// <see cref="ProductConfig.CustomWarrantyPeriodsEnabled"/> is on.
 /// <para>
 /// Always in months (a "2 year" entry is stored as 24). Like <see cref="ItemType"/> it is
 /// deliberately unlinked: an item stores the number of months itself, not a reference, so
 /// deactivating a period only stops it being offered — items already using it keep it.
 /// The length is immutable (no PUT); a different length is a different row.
 /// </para>
 /// </summary>
 public class WarrantyPeriod
 {
    public int WarrantyPeriodId { get; set; }
    public int Months { get; set; }
    public EntityStatus Status { get; set; } = EntityStatus.Active;
    public DateTime CreatedAt { get; set; }
    public DateTime? UpdatedAt { get; set; }
 }
@@ -1,42 +0,0 @@
 using ERPCore.Domain.Enums;
 namespace ERPCore.Domain.Entities;
 /// <summary>
 /// A customer's warranty, started when the sale that issued the goods is posted
 /// (docs/ITEM_TRACKING_PLAN.md Phase 5, D3/D7) — stock waiting in a warehouse never consumes
 /// warranty. For a serial item there is one row per serial (<see cref="SerialId"/> set,
 /// <see cref="Qty"/> = 1); for a warranty item that is not serial-tracked there is one row per
 /// sales line covering its <see cref="Qty"/>. <see cref="PeriodMonths"/> is the coverage
 /// snapshotted at receipt (<see cref="Serial.WarrantyPeriodMonths"/>), else the item's period.
 /// </summary>
 public class WarrantyRegistration
 {
    public int WarrantyRegistrationId { get; set; }
    public int ItemId { get; set; }
    public Item? Item { get; set; }
    public int? SerialId { get; set; }
    public Serial? Serial { get; set; }
    public int CustomerId { get; set; }
    public Customer? Customer { get; set; }
    public string SourceDocType { get; set; } = string.Empty;
    public int SourceDocId { get; set; }
    public int SourceLineId { get; set; }
    public decimal Qty { get; set; }
    public DateOnly StartDate { get; set; }
    public int PeriodMonths { get; set; }
    public DateOnly EndDate { get; set; }
    public WarrantyStatus Status { get; set; } = WarrantyStatus.Active;
    public DateTime CreatedAt { get; set; }
    public DateTime? UpdatedAt { get; set; }
    public uint RowVersion { get; set; }
 }
@@ -1,33 +1,13 @@
 namespace ERPCore.Domain.Enums;
 /// <summary>
-/// Stock-adjustment lifecycle (docs/DUAL_APPROVAL_PLAN.md §5.1). A new adjustment is a request
+/// Stock-adjustment lifecycle (docs/10 §B.8.1). Phase 1 auto-posts, so
-/// (<see cref="PendingApproval"/>, then <see cref="PendingSecondApproval"/> when two approvals are
+/// <see cref="PendingApproval"/> is reserved for the future threshold-approval
-/// required) and only moves stock when it becomes <see cref="Posted"/>. With approvals switched off
+/// workflow (FR-STK-07). Stored as a string.
 /// (<c>ApprovalConfig.StockAdjustmentLevels = 0</c>) it posts on create, as before. Stored as a string.
 /// </summary>
 public enum AdjustmentStatus
 {
    Draft,
    PendingApproval,
-    Posted,
+    Posted
    PendingSecondApproval,
    Rejected,
    Cancelled
 }
 /// <summary>Price-adjustment lifecycle — same request flow as <see cref="AdjustmentStatus"/>; <see cref="Approved"/> means applied.</summary>
 public enum PriceAdjustmentStatus
 {
    PendingApproval,
    PendingSecondApproval,
    Approved,
    Rejected,
    Cancelled
 }
 public enum ApprovalDecision
 {
    Approved,
    Rejected
 }
@@ -1,8 +0,0 @@
 namespace ERPCore.Domain.Enums;
 /// <summary>A deposit is posted as soon as it is saved; a wrong one is cancelled (GL reversed) and re-entered.</summary>
 public enum BankDepositStatus
 {
    Posted,
    Cancelled
 }
@@ -1,24 +0,0 @@
 namespace ERPCore.Domain.Enums;
 public enum ExpenseStatus
 {
    Draft,
    Posted,
    Cancelled
 }
 /// <summary>Settlement state of a Posted expense, derived from its paid/balance amounts.</summary>
 public enum ExpensePaymentStatus
 {
    Unpaid,
    PartiallyPaid,
    Paid
 }
 public enum ExpensePaymentMethod
 {
    Cash,
    BankTransfer,
    Cheque,
    Card
 }
@@ -1,12 +0,0 @@
 namespace ERPCore.Domain.Enums;
 /// <summary>How a customer paid for a sale — recorded per invoice payment (and split into
 /// cash/card amounts on slips and bundle sales) so the Day-End Sales Report can break
 /// collections down by method. Mirrors <see cref="ExpensePaymentMethod"/>.</summary>
 public enum SalesPaymentMethod
 {
    Cash,
    Card,
    BankTransfer,
    Cheque
 }
@@ -1,25 +0,0 @@
 namespace ERPCore.Domain.Enums;
 /// <summary>
 /// Lifecycle state of one serial-tracked unit (FR-WH-04). Stored as a string — the values
 /// <c>InStock</c>/<c>Sold</c> written before this enum existed stay valid as-is.
 /// Only <see cref="InStock"/> is issuable.
 /// </summary>
 public enum SerialStatus
 {
    InStock,
    Reserved,
    /// <summary>Dispatched on a stock transfer, not yet received — in no warehouse.</summary>
    InTransit,
    Sold,
    ReturnedByCustomer,
    ReturnedToVendor,
    Damaged,
    Scrapped,
    /// <summary>
    /// Left stock without being named, while serial numbers were switched off in Product
    /// Configuration — the unit was issued oldest-first like untracked stock, so which
    /// document took it is not recorded against the serial.
    /// </summary>
    IssuedUntracked
 }
@@ -1,10 +0,0 @@
 namespace ERPCore.Domain.Enums;
 /// <summary>State of a <see cref="Entities.WarrantyRegistration"/>. Stored as a string.</summary>
 public enum WarrantyStatus
 {
    Active,
    /// <summary>The unit came back on a sales return — the warranty no longer applies.</summary>
    Voided,
    Claimed
 }
@@ -27,18 +27,6 @@ public sealed class StockAdjustmentCreatedNotificationModule;
 [NotificationModule("stock.transfer.created", "Stock Transfer Created", "Raised when a stock transfer is created.", 90)]
 public sealed class StockTransferCreatedNotificationModule;
 [NotificationModule("stock.low", "Low Stock / Reorder Alert", "Raised when a sale, transfer or adjustment takes an item's stock at a warehouse to or below its reorder point.", 95)]
 public sealed class StockLowNotificationModule;
 [NotificationModule("approval.pending", "Approval Needed", "Sent to the people who can approve a stock or price adjustment that is waiting for them.", 96)]
 public sealed class ApprovalPendingNotificationModule;
 [NotificationModule("approval.approved", "Request Approved", "Sent to the requester when their stock or price adjustment is fully approved and applied.", 97)]
 public sealed class ApprovalApprovedNotificationModule;
 [NotificationModule("approval.rejected", "Request Rejected", "Sent to the requester when their stock or price adjustment is rejected.", 98)]
 public sealed class ApprovalRejectedNotificationModule;
 [NotificationModule("item.created", "Item Created", "Raised when an item master record is created.", 100)]
 public sealed class ItemCreatedNotificationModule;
@@ -1,66 +0,0 @@
 using System.ComponentModel.DataAnnotations;
 using ERPCore.Domain.Enums;
 using ERPCore.Dtos.Common;
 namespace ERPCore.Dtos.Accounts;
 // --- Cash in hand (docs/BANK_DEPOSIT_MODULE_PLAN.md §2, §7.1) ---
 /// <summary>
 /// One business day's till cash. CashIn is slip/bundle cash plus cash invoice payments received
 /// that day; CashOut is expense payments made in cash; Deposited is Posted bank deposits for that
 /// business day. Closing = Opening + NetCash − Deposited, and becomes the next day's Opening.
 /// Days before the tracking start date carry nothing in: their Opening is 0.
 /// </summary>
 public sealed record CashPositionDto(
    DateOnly Date, decimal Opening, decimal CashIn, decimal CashOut, decimal NetCash, decimal Deposited, decimal Closing);
 /// <summary>
 /// A day's cash position for the deposit form. <paramref name="AvailableToDeposit"/> is the lowest
 /// closing balance from that day up to today: a back-dated deposit lowers every later day too.
 /// <paramref name="DefaultCashAccountCode"/> is the GL cash account the form preselects.
 /// </summary>
 public sealed record CashInHandDto(
    CashPositionDto Position, decimal AvailableToDeposit, int? BranchId, DateOnly? TrackingStartDate, string TimeZone,
    string? DefaultCashAccountCode);
 public sealed record CashInHandDailyDto(
    DateOnly From, DateOnly To, IReadOnlyList<CashPositionDto> Days, int? BranchId, DateOnly? TrackingStartDate, string TimeZone);
 // --- Deposits ---
 public sealed record BankDepositDto(
    int BankDepositId, string DocNo, int BranchId, string? BranchName,
    DateOnly BusinessDate, DateOnly DepositDate, decimal Amount,
    long FromGlCashAccountId, string FromCashAccountCode, string FromCashAccountName,
    long ToGlBankAccountId, string ToBankAccountCode, string ToBankAccountName, string? ToBankName, string? ToAccountNumber,
    string? DepositSlipNo, string? DepositedBy, string? Remarks,
    BankDepositStatus Status, string? GlJournalNo, DateTime? GlPostedAt,
    string? GlReversalJournalNo, string? CancelReason, DateTime? CancelledAt,
    int CreatedBy, DateTime CreatedAt);
 /// <summary>A page of deposits plus the total amount of every row matching the filter (not just this page).</summary>
 public sealed record BankDepositListDto(IReadOnlyList<BankDepositDto> Items, PaginationDto Pagination, decimal TotalAmount);
 public sealed record BankDepositListFilter(
    DateOnly? From, DateOnly? To, int? BranchId, long? BankAccountId, BankDepositStatus? Status);
 public sealed class CreateBankDepositRequest
 {
    /// <summary>Required when branching is enabled; otherwise the default branch is used. A branch user always deposits for their own branch.</summary>
    public int BranchId { get; set; }
    [Required] public DateOnly BusinessDate { get; set; }
    /// <summary>When the bank received it; also the GL entry date. Omitted ⇒ the business date.</summary>
    public DateOnly? DepositDate { get; set; }
    [Range(0.01, 999_999_999_999)] public decimal Amount { get; set; }
    [Required] public long FromGlCashAccountId { get; set; }
    [Required] public long ToGlBankAccountId { get; set; }
    [StringLength(50)] public string? DepositSlipNo { get; set; }
    [StringLength(150)] public string? DepositedBy { get; set; }
    [StringLength(500)] public string? Remarks { get; set; }
 }
 public sealed class CancelBankDepositRequest
 {
    [Required, StringLength(250, MinimumLength = 1)] public string Reason { get; set; } = string.Empty;
 }
@@ -1,43 +0,0 @@
 using System.ComponentModel.DataAnnotations;
 using ERPCore.Domain.Enums;
 namespace ERPCore.Dtos.Approvals;
 /// <summary>One decision in a document's approval trail.</summary>
 public sealed record ApprovalStepDto(int Level, ApprovalDecision Decision, int DecidedBy, string? DecidedByName, DateTime DecidedAt, string? Comment);
 /// <summary>Settings → Approvals (docs/DUAL_APPROVAL_PLAN.md §7).</summary>
 public sealed record ApprovalConfigDto(
    int StockAdjustmentLevels, decimal StockAdjustmentLevel2ThresholdValue,
    int PriceAdjustmentLevels, decimal PriceAdjustmentLevel2ThresholdPercent,
    IReadOnlyList<string> Level2RoleCodes, DateTime? UpdatedAt);
 public sealed class UpdateApprovalConfigRequest
 {
    [Range(0, 2)] public int StockAdjustmentLevels { get; set; }
    [Range(0, double.MaxValue)] public decimal StockAdjustmentLevel2ThresholdValue { get; set; }
    [Range(0, 2)] public int PriceAdjustmentLevels { get; set; }
    [Range(0, 1000)] public decimal PriceAdjustmentLevel2ThresholdPercent { get; set; }
    public List<string> Level2RoleCodes { get; set; } = new();
 }
 public sealed class ApproveRequest
 {
    [StringLength(250)] public string? Comment { get; set; }
 }
 public sealed class RejectRequest
 {
    [Required, StringLength(250, MinimumLength = 1)] public string Reason { get; set; } = string.Empty;
 }
 /// <summary>
 /// A request waiting in the Approvals inbox. <paramref name="Level"/> is the approval it waits for
 /// (1 or 2) of <paramref name="RequiredApprovals"/>; <paramref name="CanApprove"/> says whether the
 /// current user may decide it (not the requester, not the level-1 approver, has the right role).
 /// </summary>
 public sealed record PendingApprovalDto(
    string DocType, int DocId, string DocNo, string Summary, int Level, int RequiredApprovals,
    int RequestedBy, string? RequestedByName, DateTime RequestedAt, bool CanApprove, string? WhyNot);
 public sealed record PendingApprovalsDto(IReadOnlyList<PendingApprovalDto> Items, int ActionableCount);
@@ -4,7 +4,8 @@ namespace ERPCore.Dtos.Config;
 /// <summary>Branch configuration resource — the singleton toggle for whether this deployment
 /// requires a branch on Employee/Warehouse records at all.</summary>
-public sealed record BranchConfigDto(bool BranchingEnabled, bool WarehouseBranchingEnabled, DateTime? UpdatedAt, int? UpdatedBy);
+public sealed record BranchConfigDto(
    bool BranchingEnabled, bool WarehouseBranchingEnabled, bool PurchaseOrderBranchingEnabled, DateTime? UpdatedAt, int? UpdatedBy);
 /// <summary>
 /// Full replacement of the flag. <c>UpdatedBy</c> is derived from the token, never posted.
@@ -18,4 +19,8 @@ public sealed class UpdateBranchConfigRequest
 {
    [Required] public bool? BranchingEnabled { get; set; }
    [Required] public bool? WarehouseBranchingEnabled { get; set; }
    /// <summary>Optional so existing callers that only know the first two flags keep working —
    /// omitted means "leave as is".</summary>
    public bool? PurchaseOrderBranchingEnabled { get; set; }
 }
@@ -1,50 +0,0 @@
 using System.ComponentModel.DataAnnotations;
 using ERPCore.Domain.Entities;
 namespace ERPCore.Dtos.Config;
 /// <summary>One selectable GL account, for the mapping pickers.</summary>
 public sealed record GlAccountOptionDto(string AccountCode, string AccountName, short AccountTypeId, bool IsPostable, bool IsActive);
 /// <summary>
 /// One role's current mapping. <see cref="ExistsInGl"/> is false when the saved code is not in GL's
 /// chart of accounts — which is the state 11 of these were found in on 2026-10-07. The screen shows
 /// those as flagged rather than blank, so the mapping that is actually stored stays visible.
 /// </summary>
 public sealed record GlAccountMappingDto(
    string Role, string? AccountCode, string? AccountName, bool ExistsInGl, bool IsPostable);
 /// <summary>
 /// GL account mapping resource. Carries the options alongside the mappings so the picker and the
 /// server's validation list are the same data — a code the user can choose is a code that will save.
 /// <para>
 /// <see cref="GlUnavailable"/> is true when GL could not be reached: mappings still render from the
 /// database, <see cref="Options"/> is empty, and saving will be refused until GL answers.
 /// </para>
 /// </summary>
 public sealed record GlAccountConfigDto(
    IReadOnlyList<GlAccountMappingDto> Mappings,
    IReadOnlyList<GlAccountOptionDto> Options,
    bool GlUnavailable,
    DateTime? UpdatedAt,
    int? UpdatedBy);
 /// <summary>
 /// Full replacement of the mapping. Every role is sent on every save; null or empty clears a role.
 /// <c>UpdatedBy</c> is derived from the token, never posted.
 /// </summary>
 public sealed class UpdateGlAccountConfigRequest
 {
    [MaxLength(GlAccountConfig.CodeMaxLength)] public string? InventoryAccountCode { get; set; }
    [MaxLength(GlAccountConfig.CodeMaxLength)] public string? VatRecoverableAccountCode { get; set; }
    [MaxLength(GlAccountConfig.CodeMaxLength)] public string? AccountsReceivableCode { get; set; }
    [MaxLength(GlAccountConfig.CodeMaxLength)] public string? ClearingAccountCode { get; set; }
    [MaxLength(GlAccountConfig.CodeMaxLength)] public string? TaxPayableAccountCode { get; set; }
    [MaxLength(GlAccountConfig.CodeMaxLength)] public string? AccountsPayableCode { get; set; }
    [MaxLength(GlAccountConfig.CodeMaxLength)] public string? SalesRevenueAccountCode { get; set; }
    [MaxLength(GlAccountConfig.CodeMaxLength)] public string? SalesDiscountAccountCode { get; set; }
    [MaxLength(GlAccountConfig.CodeMaxLength)] public string? InventoryGainAccountCode { get; set; }
    [MaxLength(GlAccountConfig.CodeMaxLength)] public string? CogsAccountCode { get; set; }
    [MaxLength(GlAccountConfig.CodeMaxLength)] public string? InventoryLossAccountCode { get; set; }
    [MaxLength(GlAccountConfig.CodeMaxLength)] public string? CashAccountCode { get; set; }
 }
@@ -1,22 +0,0 @@
 using System.ComponentModel.DataAnnotations;
 namespace ERPCore.Dtos.Config;
 /// <summary>GRN configuration resource.</summary>
 public sealed record GrnConfigDto(
    bool AllowWarehouseSelection, int? DefaultWarehouseId, string? DefaultWarehouseName, bool AllowDiscounts, bool AllowVat,
    DateTime? UpdatedAt, int? UpdatedBy);
 /// <summary>
 /// Full replacement of the flags. <c>UpdatedBy</c> is derived from the token, never posted.
 /// Nullable bool so an omitted flag is a 400 rather than silently binding to <c>false</c>
 /// (same reasoning as <see cref="UpdateSalesConfigRequest"/>).
 /// </summary>
 public sealed class UpdateGrnConfigRequest
 {
    [Required] public bool? AllowWarehouseSelection { get; set; }
    /// <summary>Required when <see cref="AllowWarehouseSelection"/> is false.</summary>
    public int? DefaultWarehouseId { get; set; }
    [Required] public bool? AllowDiscounts { get; set; }
    [Required] public bool? AllowVat { get; set; }
 }
@@ -12,8 +12,6 @@ namespace ERPCore.Dtos.Config;
 public sealed record ProductConfigDto(
    bool SubcategoriesEnabled, bool BrandsEnabled, bool ItemTypesEnabled,
    bool SellingPricesEnabled, bool SerialNumbersEnabled, bool BatchListsEnabled, bool WarrantyPeriodsEnabled,
    bool CustomVariantsEnabled, bool ItemImagesEnabled,
    bool CustomWarrantyPeriodsEnabled,
    DateTime? UpdatedAt, int? UpdatedBy);
 /// <summary>
@@ -34,7 +32,4 @@ public sealed class UpdateProductConfigRequest
    [Required] public bool? SerialNumbersEnabled { get; set; }
    [Required] public bool? BatchListsEnabled { get; set; }
    [Required] public bool? WarrantyPeriodsEnabled { get; set; }
    [Required] public bool? CustomVariantsEnabled { get; set; }
    [Required] public bool? ItemImagesEnabled { get; set; }
    [Required] public bool? CustomWarrantyPeriodsEnabled { get; set; }
 }
@@ -1,25 +0,0 @@
 using System.ComponentModel.DataAnnotations;
 namespace ERPCore.Dtos.Config;
 /// <summary>Sales configuration resource. <c>CashCustomerId</c>/<c>CashCustomerName</c> identify
 /// the generic cash customer (null until the option has been switched on at least once).</summary>
 public sealed record SalesConfigDto(
    bool AllowCashCustomer, int? CashCustomerId, string? CashCustomerName, bool AllowFreeItems, bool AllowDiscounts, bool AllowOverStockSale,
    bool AllowWarehouseSelection, int? DefaultWarehouseId, string? DefaultWarehouseName, DateTime? UpdatedAt, int? UpdatedBy);
 /// <summary>
 /// Full replacement of the flags. <c>UpdatedBy</c> is derived from the token, never posted.
 /// Nullable bool so an omitted flag is a 400 rather than silently binding to <c>false</c>
 /// (same reasoning as <see cref="UpdateBranchConfigRequest"/>).
 /// </summary>
 public sealed class UpdateSalesConfigRequest
 {
    [Required] public bool? AllowCashCustomer { get; set; }
    [Required] public bool? AllowFreeItems { get; set; }
    [Required] public bool? AllowDiscounts { get; set; }
    [Required] public bool? AllowOverStockSale { get; set; }
    [Required] public bool? AllowWarehouseSelection { get; set; }
    /// <summary>Required when <see cref="AllowWarehouseSelection"/> is false.</summary>
    public int? DefaultWarehouseId { get; set; }
 }
@@ -4,9 +4,6 @@ using ERPCore.Domain.Enums;
 namespace ERPCore.Dtos.Customers;
 /// <summary>Customer resource used by sales documents.</summary>
 /// <param name="OutstandingAmount">Unpaid balance across the customer's Posted sales invoices. Filled on the list only.</param>
 /// <param name="OutstandingInvoiceCount">Posted sales invoices with a balance still due. Filled on the list only.</param>
 /// <param name="LastPaymentDate">When the customer last paid against an invoice; null if never. Filled on the list only.</param>
 public sealed record CustomerDto(
    int CustomerId,
    string CustomerCode,
@@ -26,10 +23,7 @@ public sealed record CustomerDto(
    EntityStatus Status,
    int BranchId,
    DateTime CreatedAt,
-    DateTime? UpdatedAt,
+    DateTime? UpdatedAt);
    decimal OutstandingAmount = 0m,
    int OutstandingInvoiceCount = 0,
    DateTime? LastPaymentDate = null);
 public sealed class CreateCustomerRequest
 {
@@ -18,17 +18,13 @@ public sealed record DashboardStatsDto(
    decimal StockValuationTotal,
    IReadOnlyList<WarehouseValuationDto> StockValuationByWarehouse,
    int PendingApprovalPurchaseOrders,
    int FullyReceivedPurchaseOrders,
    int PendingGrns,
    int OpenRequisitions,
    int PendingCounts,
    int OpenRfqs,
    int PendingLeaveRequests,
-    int OverdueSalesInvoices,
+    int OverdueSalesInvoices);
    IReadOnlyList<MonthlyPurchasesVsSalesDto> MonthlyPurchasesVsSales);
 /// <summary>One bar in the Stock Valuation chart — total FIFO layer value for a warehouse.</summary>
 public sealed record WarehouseValuationDto(int WarehouseId, decimal Total);
 /// <summary>One month in the Monthly Purchases chart (Purchase Invoices page) — GrandTotal
 /// of Posted purchase invoices vs Posted sales invoices. <c>Month</c> is "yyyy-MM".</summary>
 public sealed record MonthlyPurchasesVsSalesDto(string Month, decimal Purchases, decimal Sales);
@@ -1,120 +0,0 @@
 using System.ComponentModel.DataAnnotations;
 using ERPCore.Domain.Enums;
 namespace ERPCore.Dtos.Expenses;
 // --- Setup: categories and titles (docs/EXPENSE_MODULE_PLAN.md §6 "Setup") ---
 public sealed record ExpenseTitleDto(
    int ExpenseTitleId, int ExpenseCategoryId, string Name, string GlExpenseAccountCode,
    bool IsSystem, EntityStatus Status, int SortOrder);
 public sealed record ExpenseCategoryDto(
    int ExpenseCategoryId, string Code, string Name, bool IsSystem, EntityStatus Status, int SortOrder,
    IReadOnlyList<ExpenseTitleDto> Titles);
 public sealed class UpdateExpenseCategoryRequest
 {
    /// <summary>Ignored-if-unchanged for system rows; a different name on a system row is rejected.</summary>
    [Required, StringLength(100, MinimumLength = 1)] public string Name { get; set; } = string.Empty;
    public EntityStatus Status { get; set; } = EntityStatus.Active;
 }
 public sealed class CreateExpenseTitleRequest
 {
    [Required, StringLength(100, MinimumLength = 1)] public string Name { get; set; } = string.Empty;
    [Required, StringLength(20, MinimumLength = 1)] public string GlExpenseAccountCode { get; set; } = string.Empty;
 }
 public sealed class UpdateExpenseTitleRequest
 {
    /// <summary>Ignored-if-unchanged for system rows; a different name on a system row is rejected.</summary>
    [Required, StringLength(100, MinimumLength = 1)] public string Name { get; set; } = string.Empty;
    [Required, StringLength(20, MinimumLength = 1)] public string GlExpenseAccountCode { get; set; } = string.Empty;
    public EntityStatus Status { get; set; } = EntityStatus.Active;
 }
 // --- Expenses ---
 public sealed record ExpenseSummaryDto(
    int ExpenseId, string DocNo, int BranchId, DateOnly ExpenseDate, DateOnly? DueDate,
    int ExpenseCategoryId, string CategoryName, int ExpenseTitleId, string TitleName,
    string? Payee, string? BillReference, string? PeriodMonth,
    decimal Amount, decimal PaidAmount, decimal BalanceAmount,
    ExpenseStatus Status, ExpensePaymentStatus PaymentStatus, string? GlJournalNo, DateTime CreatedAt);
 public sealed record ExpensePaymentDto(
    int ExpensePaymentId, int ExpenseId, decimal Amount, DateTime PaymentDate, ExpensePaymentMethod PaymentMethod,
    long GlBankAccountId, string BankAccountName, string? ChequeNo, string? Reference, string? GlJournalNo, DateTime CreatedAt);
 public sealed record ExpenseDto(
    int ExpenseId, string DocNo, int BranchId, DateOnly ExpenseDate, DateOnly? DueDate,
    int ExpenseCategoryId, string CategoryName, int ExpenseTitleId, string TitleName,
    string? Payee, int? VendorId, string? VendorName, string? BillReference, string? Description, string? PeriodMonth,
    decimal Amount, decimal PaidAmount, decimal BalanceAmount,
    ExpenseStatus Status, ExpensePaymentStatus PaymentStatus,
    string? GlExpenseAccountCode, string? GlJournalNo, DateTime? GlPostedAt, string? GlReversalJournalNo, string? CancelReason,
    int CreatedBy, DateTime CreatedAt, DateTime? UpdatedAt,
    IReadOnlyList<ExpensePaymentDto> Payments);
 public class ExpenseRequestBase
 {
    /// <summary>Required when branching is enabled; otherwise the default branch is used.</summary>
    public int BranchId { get; set; }
    [Required] public DateOnly ExpenseDate { get; set; }
    public DateOnly? DueDate { get; set; }
    [Required] public int ExpenseCategoryId { get; set; }
    [Required] public int ExpenseTitleId { get; set; }
    [StringLength(150)] public string? Payee { get; set; }
    public int? VendorId { get; set; }
    [StringLength(50)] public string? BillReference { get; set; }
    [StringLength(500)] public string? Description { get; set; }
    [RegularExpression(@"^\d{4}-(0[1-9]|1[0-2])$", ErrorMessage = "PeriodMonth must be yyyy-MM.")]
    public string? PeriodMonth { get; set; }
    [Range(0.01, 999_999_999_999)] public decimal Amount { get; set; }
 }
 public sealed class CreateExpenseRequest : ExpenseRequestBase;
 public sealed class UpdateExpenseRequest : ExpenseRequestBase;
 public sealed class CancelExpenseRequest
 {
    [Required, StringLength(250, MinimumLength = 1)] public string Reason { get; set; } = string.Empty;
 }
 public sealed class ExpensePaymentLineRequest
 {
    [Required] public long GlBankAccountId { get; set; }
    [Range(0.01, double.MaxValue)] public decimal Amount { get; set; }
 }
 /// <summary>
 /// One payment submission: one or more lines (e.g. part cash, part bank), all posted in a
 /// single GL journal entry. Total must not exceed the balance (for Post &amp; Pay, the amount); partial is fine.
 /// </summary>
 public sealed class CreateExpensePaymentRequest
 {
    [Required, MinLength(1)] public List<ExpensePaymentLineRequest> Lines { get; set; } = new();
    public ExpensePaymentMethod PaymentMethod { get; set; } = ExpensePaymentMethod.Cash;
    /// <summary>Required when <see cref="PaymentMethod"/> is Cheque.</summary>
    [StringLength(30)] public string? ChequeNo { get; set; }
    [StringLength(100)] public string? Reference { get; set; }
    /// <summary>When it was paid; also the GL entry date. Omitted ⇒ today. Never in the future.</summary>
    public DateOnly? PaymentDate { get; set; }
 }
 public sealed record ExpenseListFilter(
    ExpenseStatus? Status, ExpensePaymentStatus? PaymentStatus, int? CategoryId, int? TitleId,
    DateOnly? From, DateOnly? To, bool OverdueOnly);
 public sealed record ExpenseTitleTotalDto(int ExpenseTitleId, string TitleName, decimal Amount, int Count);
 public sealed record ExpenseCategoryTotalDto(
    int ExpenseCategoryId, string CategoryName, decimal Amount, int Count, IReadOnlyList<ExpenseTitleTotalDto> Titles);
 /// <summary>Posted (non-cancelled) expenses dated within [From, To], plus the all-time unpaid/overdue position.</summary>
 public sealed record ExpenseSummaryReportDto(
    DateOnly From, DateOnly To, decimal TotalAmount, decimal PaidAmount, decimal UnpaidAmount, int Count,
    decimal OutstandingAmount, decimal OverdueAmount, int OverdueCount, int DraftCount,
    IReadOnlyList<ExpenseCategoryTotalDto> Categories);
@@ -7,16 +7,12 @@ namespace ERPCore.Dtos.Grn;
 public sealed record GrnLineWarrantyNumberDto(string WarrantyNo, int WarrantyPeriodMonths);
 /// <summary>A serial captured on a GRN line; <see cref="SerialId"/> is set once the GRN is confirmed.</summary>
 public sealed record GrnLineSerialDto(string SerialNo, int? SerialId);
 public sealed record GrnLineDto(
    int GrnLineId, int? PoLineId, int ItemId, int? BinId,
    decimal Qty, decimal UnitCost, decimal? PoUnitPrice,
    decimal DiscountPct, decimal NetUnitCost, decimal VatPct, decimal VatAmount,
    decimal ReceivedValue, decimal LineTotal, decimal PriceVariance,
-    HoldStatus HoldStatus, int? BatchId, IReadOnlyList<GrnLineWarrantyNumberDto> WarrantyNumbers,
+    HoldStatus HoldStatus, int? BatchId, IReadOnlyList<GrnLineWarrantyNumberDto> WarrantyNumbers);
    string? BatchNo, DateOnly? BatchExpiryDate, IReadOnlyList<GrnLineSerialDto> Serials);
 public sealed record GrnDto(
    int GrnId, string DocNo, int? PoId, int VendorId, int WarehouseId, int BranchId, GrnStatus Status,
@@ -74,15 +70,9 @@ public sealed class CreateGrnLineInput
    public BatchInput? Batch { get; set; }
    /// <summary>
    /// Required, one per unit (count must equal <see cref="Qty"/>), when the item is
-    /// warranty-tracked (<c>Item.Warranty == Warranty.Warranty</c>) and not serial-tracked —
+    /// warranty-tracked (<c>Item.Warranty == Warranty.Warranty</c>). Ignored otherwise.
    /// a serial item's serial is its warranty identity. Ignored otherwise.
    /// </summary>
    public List<string>? WarrantyNumbers { get; set; }
    /// <summary>
    /// Required, one per unit (count must equal <see cref="Qty"/>, so Qty must be whole), when the
    /// item is serial-tracked (<c>Item.TrackingMode == Serial</c>). Rejected for any other item.
    /// </summary>
    public List<string>? SerialNumbers { get; set; }
 }
 public sealed class CreateGrnRequest
@@ -133,6 +133,5 @@ public sealed class ReorderSettingInput
 public sealed class UpdateReorderRequest
 {
-    /// <summary>The complete set — an empty list removes every rule for the item.</summary>
+    [Required, MinLength(1)] public List<ReorderSettingInput> Settings { get; set; } = new();
    [Required] public List<ReorderSettingInput> Settings { get; set; } = new();
 }
@@ -1,7 +0,0 @@
 namespace ERPCore.Dtos.Items;
 /// <summary>An item photo's metadata. The bytes are served by
 /// <c>GET /items/{itemId}/images/{itemImageId}/content</c>.</summary>
 public sealed record ItemImageDto(
    int ItemImageId, int ItemId, string FileName, string ContentType, long SizeBytes,
    int SortOrder, DateTime UploadedAt);
@@ -2,14 +2,6 @@ using ERPCore.Domain.Enums;
 namespace ERPCore.Dtos.Items;
 /// <summary>
 /// One posted GRN receipt of an item — what it was bought at. <paramref name="NetUnitCost"/> is the
 /// cost after trade discount (the FIFO stock cost, VAT excluded) — the figure to price against.
 /// </summary>
 public sealed record ItemPurchasePriceDto(
    int GrnId, string GrnDocNo, DateTime ReceivedAt, int VendorId, string? VendorName, string? WarehouseCode,
    decimal Qty, decimal UnitCost, decimal DiscountPct, decimal NetUnitCost, decimal VatPct);
 /// <summary>
 /// Item row enriched with cross-module aggregates (current FIFO stock value, low-stock
 /// flag, last purchase, trailing-30-day sales) for the Items list page. Deliberately a
@@ -24,12 +16,3 @@ public sealed record ItemOverviewDto(
    decimal StockQty, decimal StockValue, bool IsLowStock,
    DateTime? LastPurchaseDate, int? LastSupplierId, string? LastSupplierName,
    decimal SalesQtyLast30Days);
 /// <summary>Stock-state filter for the Items overview. <c>LowStock</c> uses the same rule
 /// as <see cref="ItemOverviewDto.IsLowStock"/>: on-hand at or below any warehouse's reorder point.</summary>
 public enum ItemStockFilter
 {
    InStock,
    OutOfStock,
    LowStock
 }
@@ -1,17 +0,0 @@
 using System.ComponentModel.DataAnnotations;
 using ERPCore.Domain.Enums;
 namespace ERPCore.Dtos.Items;
 public sealed record WarrantyPeriodDto(int WarrantyPeriodId, int Months, EntityStatus Status, DateTime CreatedAt, DateTime? UpdatedAt);
 /// <summary>A new custom length, always in months (the client converts years).</summary>
 public sealed class CreateWarrantyPeriodRequest
 {
    [Required] public int? Months { get; set; }
 }
 public sealed class UpdateWarrantyPeriodStatusRequest
 {
    [Required] public EntityStatus Status { get; set; }
 }
@@ -31,8 +31,6 @@ public sealed class CreatePurchaseInvoicePaymentRequest
    [Range(0.01, double.MaxValue)] public decimal Amount { get; set; }
    [Required] public long GlBankAccountId { get; set; }
    [StringLength(100)] public string? Reference { get; set; }
    /// <summary>When the vendor was paid; also the GL entry date. Omitted ⇒ today. Never in the future.</summary>
    public DateOnly? PaymentDate { get; set; }
 }
 public sealed class CreatePurchaseInvoiceRequest
@@ -25,12 +25,6 @@ public sealed class CreatePurchaseReturnLineInput
    public int? GrnLineId { get; set; }
    [Required] public int ItemId { get; set; }
    [Range(0.0001, double.MaxValue)] public decimal Qty { get; set; }
    /// <summary>
    /// Serials sent back, for a serial-tracked item — one per unit, each at the return warehouse
    /// (InStock or Damaged; for a rejected GRN line, received on that line). They become
    /// <c>ReturnedToVendor</c>. Rejected for any other item.
    /// </summary>
    public List<int>? SerialIds { get; set; }
 }
 public sealed class CreatePurchaseReturnRequest
@@ -1,47 +0,0 @@
 using System.ComponentModel.DataAnnotations;
 using ERPCore.Domain.Enums;
 using ERPCore.Dtos.Approvals;
 namespace ERPCore.Dtos.Products;
 /// <summary>One item's requested change. Current* are the item's prices now — they differ from Old* when it was repriced since.</summary>
 public sealed record PriceAdjustmentLineDto(
    int PriceAdjustmentLineId, int ItemId, string Sku, string ItemName,
    decimal? OldMinPrice, decimal? OldMaxPrice, decimal? OldFlatPrice,
    decimal? NewMinPrice, decimal? NewMaxPrice, decimal? NewFlatPrice,
    decimal? CurrentMinPrice, decimal? CurrentMaxPrice, decimal? CurrentFlatPrice);
 public sealed record PriceAdjustmentSummaryDto(
    int PriceAdjustmentId, string DocNo, string Reason, PriceAdjustmentStatus Status, int RequiredApprovals, int? PendingLevel,
    int LineCount, int CreatedBy, string? CreatedByName, DateTime CreatedAt, DateTime? AppliedAt);
 /// <param name="PendingLevel">The approval it waits for (1 or 2); null once decided.</param>
 public sealed record PriceAdjustmentDto(
    int PriceAdjustmentId, string DocNo, string Reason, PriceAdjustmentStatus Status, int RequiredApprovals, int? PendingLevel,
    int CreatedBy, string? CreatedByName, DateTime CreatedAt,
    int? ApprovedLevel1By, DateTime? ApprovedLevel1At, int? ApprovedLevel2By, DateTime? ApprovedLevel2At,
    int? RejectedBy, DateTime? RejectedAt, string? RejectReason, DateTime? CancelledAt, DateTime? AppliedAt,
    IReadOnlyList<PriceAdjustmentLineDto> Lines, IReadOnlyList<ApprovalStepDto> ApprovalHistory, bool CanApprove, string? WhyNot,
    bool CanWithdraw);
 public sealed class PriceAdjustmentLineInput
 {
    [Required] public int ItemId { get; set; }
    /// <summary>The prices the item should have afterwards — null clears that price.</summary>
    [Range(0, double.MaxValue)] public decimal? NewMinPrice { get; set; }
    [Range(0, double.MaxValue)] public decimal? NewMaxPrice { get; set; }
    [Range(0, double.MaxValue)] public decimal? NewFlatPrice { get; set; }
 }
 public sealed class CreatePriceAdjustmentRequest
 {
    [Required, StringLength(250, MinimumLength = 1)] public string Reason { get; set; } = string.Empty;
    [Required, MinLength(1)] public List<PriceAdjustmentLineInput> Lines { get; set; } = new();
 }
 public sealed record ItemPriceHistoryDto(
    int ItemPriceHistoryId, int ItemId, int? PriceAdjustmentId, string? DocNo,
    decimal? OldMinPrice, decimal? OldMaxPrice, decimal? OldFlatPrice,
    decimal? NewMinPrice, decimal? NewMaxPrice, decimal? NewFlatPrice,
    int RequestedBy, string? RequestedByName, int? ApprovedLevel1By, string? ApprovedLevel1ByName,
    int? ApprovedLevel2By, string? ApprovedLevel2ByName, DateTime AppliedAt);
@@ -8,7 +8,12 @@ namespace ERPCore.Dtos.Rbac;
 /// branch pickers client-side only (no server-side branch enforcement exists yet,
 /// see docs/BRANCH_ISOLATION_PLAN.md). <see cref="BranchingEnabled"/> mirrors the
 /// singleton <c>BranchConfig</c> toggle — when false the frontend hides branch pickers
-/// entirely rather than merely restricting them by role.</summary>
+/// entirely rather than merely restricting them by role. <see cref="MustChangePassword"/>
 /// is true for an admin-created account that hasn't replaced its issued password yet —
 /// the frontend holds the user on the change-password screen until it is false.</summary>
 public sealed record MeResponseDto(
    string? RoleCode, string? RoleName, IReadOnlyList<string> NavCodes,
-    bool IsAdmin, int? BranchId, string? BranchName, bool BranchingEnabled, bool WarehouseBranchingEnabled);
+    bool IsAdmin, int? BranchId, string? BranchName, bool BranchingEnabled, bool WarehouseBranchingEnabled,
    bool MustChangePassword = false,
    bool PurchaseOrderBranchingEnabled = true,
    int? UserId = null);
@@ -1,51 +0,0 @@
 namespace ERPCore.Dtos.Reports;
 /// <summary>
 /// One business day's figures (or, with <see cref="Date"/> null, a range's totals) — docs/DAY_END_SALES_REPORT_PLAN.md §4.
 /// Sales are Posted slips, bundle sales and invoices dated that day; Paid is what has been paid on
 /// those sales so far (split by how it was paid) and Due the rest.
 /// </summary>
 /// <param name="Income">TotalSales − ExpenseTotal (sales returns aren't priced, so they can't be netted off).</param>
 /// <param name="CostOfGoodsSold">FIFO cost of the stock those sales issued (the stock ledger's Out value).</param>
 /// <param name="GrossProfit">TotalSales − CostOfGoodsSold.</param>
 /// <param name="NetProfit">GrossProfit − ExpenseTotal; negative is a loss.</param>
 /// <param name="EarlierInvoiceCollections">Invoice payments received this day against invoices from
 /// earlier days — not part of PaidAmount.</param>
 /// <param name="NetCash">Cash that came in this day (slip/bundle cash + cash invoice payments, any
 /// invoice) minus expenses paid in cash this day — a till check.</param>
 /// <param name="OpeningCashInHand">Cash left in the till from earlier days (docs/BANK_DEPOSIT_MODULE_PLAN.md §9).
 /// For a range's totals, the first day's opening.</param>
 /// <param name="CashDeposited">Posted bank deposits made against this business day.</param>
 /// <param name="ClosingCashInHand">Opening + NetCash − CashDeposited: cash still in hand. For a range's totals, the last day's closing.</param>
 public sealed record DayEndReportDayDto(
    DateOnly? Date,
    decimal TotalSales, decimal PaidAmount, decimal DueAmount,
    decimal PaidByCash, decimal PaidByCard, decimal PaidByOther,
    int SalesCount, int CashSalesCount, int CardSalesCount, int MixedSalesCount, int OtherSalesCount, int UnpaidSalesCount,
    decimal ExpenseTotal, decimal Income,
    decimal CostOfGoodsSold, decimal GrossProfit, decimal NetProfit,
    decimal EarlierInvoiceCollections,
    decimal NetCash,
    decimal OpeningCashInHand, decimal CashDeposited, decimal ClosingCashInHand);
 /// <summary>One sale of the day. <paramref name="PaidBy"/> is Cash, Card, Bank transfer, Cheque, Mixed or Unpaid.</summary>
 public sealed record DayEndReportSaleDto(
    string DocType, int DocId, string DocNo, DateTime At, string CustomerName,
    decimal Total, decimal Paid, decimal Due, string PaidBy, decimal Cost, decimal GrossProfit);
 public sealed record DayEndReportExpenseDto(
    int ExpenseId, string DocNo, string CategoryName, string TitleName, string? Payee, decimal Amount, decimal PaidAmount);
 /// <summary>A Posted bank deposit of this business day's cash.</summary>
 public sealed record DayEndReportDepositDto(
    int BankDepositId, string DocNo, string BankAccountName, string? BankName, string? AccountNumber,
    string? DepositSlipNo, DateOnly DepositDate, decimal Amount);
 /// <summary>A single day: its figures plus the sales, expenses and bank deposits behind them.</summary>
 public sealed record DayEndReportDto(
    DayEndReportDayDto Summary, IReadOnlyList<DayEndReportSaleDto> Sales, IReadOnlyList<DayEndReportExpenseDto> Expenses,
    IReadOnlyList<DayEndReportDepositDto> Deposits, int? BranchId, string TimeZone);
 /// <summary>Day-wise figures for a range (every day present, zeros on quiet days) plus the range's totals.</summary>
 public sealed record DayEndDailyReportDto(
    DateOnly From, DateOnly To, IReadOnlyList<DayEndReportDayDto> Days, DayEndReportDayDto Totals, int? BranchId, string TimeZone);
@@ -12,7 +12,7 @@ public sealed record BundleSaleDto(
    int WarehouseId, int CashierUserId, int BundleSaleTemplateId, string BundleName, string BundleCode,
    BundleSaleStatus Status, decimal ComponentSubtotal, decimal BundlePrice, decimal MarginAmount,
    decimal DiscountTotal, decimal TaxTotal, decimal GrandTotal, DateTime CreatedAt, DateTime? UpdatedAt,
-    IReadOnlyList<BundleSaleLineDto> Lines, decimal CashAmount, decimal CardAmount);
+    IReadOnlyList<BundleSaleLineDto> Lines);
 public sealed record BundleSaleSummaryDto(
    int BundleSaleId, string BundleNo, DateTime BundleDate, int CustomerId, string CustomerSnapshotName,
@@ -66,8 +66,6 @@ public sealed class CreateBundleSaleRequest
    [Range(0, double.MaxValue)] public decimal BundlePrice { get; set; }
    public bool AllowPriceOverride { get; set; }
    [Required, MinLength(1)] public List<CreateBundleSaleTemplateLineRequest> Lines { get; set; } = new();
    /// <summary>The part of the total tendered by card; the rest is cash. Omit for all cash.</summary>
    [Range(0, double.MaxValue)] public decimal? CardAmount { get; set; }
 }
 public sealed class UpdateBundleSaleRequest
@@ -80,6 +78,4 @@ public sealed class UpdateBundleSaleRequest
    [Range(0, double.MaxValue)] public decimal BundlePrice { get; set; }
    public bool AllowPriceOverride { get; set; }
    [Required, MinLength(1)] public List<CreateBundleSaleTemplateLineRequest> Lines { get; set; } = new();
    /// <summary>See <see cref="CreateBundleSaleRequest.CardAmount"/>.</summary>
    [Range(0, double.MaxValue)] public decimal? CardAmount { get; set; }
 }
--- a/Show More
+++ b/Show More