Dhananjaya99
a0793b35d3
- Introduced a new column 'AccruedExpensesCode' of type varchar(20) to the 'gl_account_config' table. - Added SQL command to update existing records with a default value of '2300' for the 'AccruedExpensesCode' where it is currently null.
490 lines
24 KiB
C#
490 lines
24 KiB
C#
using ERPCore.Domain;
|
|
using ERPCore.Domain.Entities;
|
|
using ERPCore.Domain.Enums;
|
|
using ERPCore.Dtos.Approvals;
|
|
using ERPCore.Dtos.Common;
|
|
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.Gl;
|
|
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;
|
|
// ReasonId is an ordinary adjustment reason (VAR); WastageReasonId is a wastage one (DMG), which has its own approval switch.
|
|
private const int ItemId = 1, WarehouseId = 1, ReasonId = 1, WastageReasonId = 2;
|
|
|
|
// --- 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(level2RoleIds: ApproverRoleId.ToString());
|
|
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));
|
|
|
|
// --- Wastage: its own approval switch ------------------------------------------------------
|
|
|
|
[Fact]
|
|
public async Task Wastage_WithTheSwitchOff_ReducesStockAtOnce_EvenWhenAdjustmentsNeedTwoApprovals()
|
|
{
|
|
var h = await Harness.CreateAsync(stockLevels: 2, wastageLevels: 0);
|
|
|
|
var dto = await h.Stock.CreateAsync(Request(-3, WastageReasonId));
|
|
|
|
Assert.Equal(AdjustmentStatus.Posted, dto.Status);
|
|
Assert.Equal(0, dto.RequiredApprovals);
|
|
Assert.Single(h.Mutator.Calls);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Wastage_WithTheSwitchOn_IsARequest_AndMovesNothingUntilApproved()
|
|
{
|
|
var h = await Harness.CreateAsync(stockLevels: 0, wastageLevels: 2);
|
|
|
|
var dto = await h.Stock.CreateAsync(Request(-3, WastageReasonId));
|
|
|
|
Assert.Equal(AdjustmentStatus.PendingApproval, dto.Status);
|
|
Assert.Equal(2, dto.RequiredApprovals);
|
|
Assert.Empty(h.Mutator.Calls);
|
|
|
|
h.User.Be(ApproverA);
|
|
await h.Stock.ApproveAsync(dto.AdjustmentId, null);
|
|
Assert.Empty(h.Mutator.Calls); // one of two: still nothing
|
|
h.User.Be(ApproverB);
|
|
var posted = await h.Stock.ApproveAsync(dto.AdjustmentId, null);
|
|
Assert.Equal(AdjustmentStatus.Posted, posted.Status);
|
|
Assert.Single(h.Mutator.Calls);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task TheWastageSwitch_DoesNotLoosenOrdinaryAdjustments_AndTheirLevelsDoNotTouchWastage()
|
|
{
|
|
var h = await Harness.CreateAsync(stockLevels: 2, wastageLevels: 0);
|
|
|
|
// An ordinary adjustment (not a wastage reason) still needs two approvals.
|
|
var ordinary = await h.Stock.CreateAsync(Request(-3));
|
|
Assert.Equal(AdjustmentStatus.PendingApproval, ordinary.Status);
|
|
|
|
// A stock GAIN with a wastage reason is not wastage, so it follows the adjustment levels too.
|
|
var gain = await h.Stock.CreateAsync(Request(+3, WastageReasonId));
|
|
Assert.Equal(AdjustmentStatus.PendingApproval, gain.Status);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task WastageList_ReturnsOnlyAdjustmentsWithAWastageReason()
|
|
{
|
|
var h = await Harness.CreateAsync(stockLevels: 0, wastageLevels: 0);
|
|
await h.Stock.CreateAsync(Request(-1, WastageReasonId));
|
|
await h.Stock.CreateAsync(Request(-2));
|
|
|
|
var all = await h.Stock.ListAsync(new PageQuery { Page = 1, PageSize = 50 }, null, null, null);
|
|
var wastage = await h.Stock.ListAsync(new PageQuery { Page = 1, PageSize = 50 }, null, null, null, null, CancellationToken.None, wastageOnly: true);
|
|
|
|
Assert.Equal(2, all.Items.Count);
|
|
var only = Assert.Single(wastage.Items);
|
|
Assert.Equal(WastageReasonId, only.ReasonCodeId);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task WastageList_CanBeNarrowedToOneItem()
|
|
{
|
|
var h = await Harness.CreateAsync(stockLevels: 0, wastageLevels: 0);
|
|
await h.Stock.CreateAsync(Request(-1, WastageReasonId));
|
|
|
|
var forItem = await h.Stock.ListAsync(new PageQuery { Page = 1, PageSize = 50 }, null, null, null, null, CancellationToken.None, wastageOnly: true, itemId: ItemId);
|
|
var otherItem = await h.Stock.ListAsync(new PageQuery { Page = 1, PageSize = 50 }, null, null, null, null, CancellationToken.None, wastageOnly: true, itemId: 999);
|
|
|
|
Assert.Single(forItem.Items);
|
|
Assert.Empty(otherItem.Items);
|
|
}
|
|
|
|
[Fact]
|
|
public void WastageApproval_IsOffByDefault_AndTheSettingIsReadBack()
|
|
{
|
|
Assert.Equal(0, new ApprovalConfig().WastageLevels);
|
|
Assert.True(ERPCore.Domain.WastageReasonCodes.IsWastage("dmg"));
|
|
Assert.False(ERPCore.Domain.WastageReasonCodes.IsWastage("VAR"));
|
|
}
|
|
|
|
// --- helpers ------------------------------------------------------------------------------
|
|
|
|
private static CreateAdjustmentRequest Request(decimal qty, int reasonId = ReasonId) => 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? level2RoleIds = null, int wastageLevels = 0)
|
|
{
|
|
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.AddRange(
|
|
new ReasonCode { ReasonCodeId = ReasonId, Code = "VAR", Description = "Variance", Context = ReasonContext.Adjustment },
|
|
new ReasonCode { ReasonCodeId = WastageReasonId, Code = "DMG", Description = "Damage", Context = ReasonContext.Adjustment });
|
|
db.ApprovalConfig.Add(new ApprovalConfig
|
|
{
|
|
ApprovalConfigId = ApprovalConfig.SingletonId, StockAdjustmentLevels = stockLevels,
|
|
StockAdjustmentLevel2ThresholdValue = stockThreshold, PriceAdjustmentLevels = 2, Level2RoleIds = level2RoleIds,
|
|
WastageLevels = wastageLevels
|
|
});
|
|
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), new Repository<Role>(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 StubGlAccountConfigService(
|
|
(GlAccountRole.Inventory, "1200"),
|
|
(GlAccountRole.InventoryGain, "4900"),
|
|
(GlAccountRole.InventoryLoss, "5900")),
|
|
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<PriceAdjustmentLine>(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"
|
|
};
|
|
|
|
private static readonly Dictionary<int, int> RoleIds = new()
|
|
{
|
|
[Requester] = 1, [ApproverA] = ApproverRoleId, [ApproverB] = ApproverRoleId, [Clerk] = ClerkRoleId
|
|
};
|
|
|
|
public int AuditUserId { get; private set; } = userId;
|
|
public int? RoleId { get; private set; } = RoleIds[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;
|
|
RoleId = RoleIds[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, bool postGlJournal = true) => 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();
|
|
}
|
|
}
|