loading event

Distribution/Features/LoadingEvent/ILoadingSheetRepository.cs

@@ -0,0 +1,16 @@
+using Distribution.Models;
+
+namespace Distribution.Features.LoadingEvent;
+
+public interface ILoadingSheetRepository
+{
+    Task<LoadingSheet?> GetByIdAsync(Guid id);
+    Task<LoadingSheet?> GetActiveByRideIdAsync(Guid rideId);
+    Task<List<LoadingSheet>> GetAllAsync(Guid? rideId, LoadingSheetStatus? status, int page, int pageSize);
+    Task<int> GetCountAsync(Guid? rideId, LoadingSheetStatus? status);
+    Task<List<(Guid ItemId, decimal TotalQty)>> GetAggregatedOrderItemsByRouteIdAsync(Guid routeId);
+    Task AddAsync(LoadingSheet sheet);
+    void Update(LoadingSheet sheet);
+    void RemoveItems(IEnumerable<LoadingSheetItem> items);
+    Task AddItemsAsync(IEnumerable<LoadingSheetItem> items);
+}

Distribution/Features/LoadingEvent/LoadingSheetController.cs

@@ -0,0 +1,113 @@
+using Distribution.Models;
+using Distribution.Infra.Authorization;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace Distribution.Features.LoadingEvent;
+
+[ApiController]
+[Route("api/loading-sheets")]
+[Authorize]
+public class LoadingSheetController(LoadingSheetService service, ICurrentUserService currentUser) : ControllerBase
+{
+    [HttpGet]
+    [Authorize(Policy = "loading.view")]
+    public async Task<IActionResult> GetAll(
+        [FromQuery] Guid? rideId,
+        [FromQuery] LoadingSheetStatus? status,
+        [FromQuery] int page = 1,
+        [FromQuery] int pageSize = 20)
+    {
+        var result = await service.GetAllAsync(rideId, status, page, pageSize);
+        return Ok(result);
+    }
+
+    [HttpGet("{id:guid}")]
+    [Authorize(Policy = "loading.view")]
+    public async Task<IActionResult> GetById(Guid id)
+    {
+        var result = await service.GetByIdAsync(id);
+        return result is null ? NotFound() : Ok(result);
+    }
+
+    [HttpPost]
+    [Authorize(Policy = "loading.dispatch")]
+    public async Task<IActionResult> Create(CreateLoadingSheetRequest request, CancellationToken ct)
+    {
+        try
+        {
+            var result = await service.CreateAsync(request, ct);
+            return CreatedAtAction(nameof(GetById), new { id = result.Id }, result);
+        }
+        catch (KeyNotFoundException) { return NotFound(); }
+        catch (InvalidOperationException ex) { return BadRequest(new { error = ex.Message }); }
+    }
+
+    [HttpPut("{id:guid}/items")]
+    [Authorize(Policy = "loading.dispatch")]
+    public async Task<IActionResult> SetItems(Guid id, SetItemsRequest request, CancellationToken ct)
+    {
+        try
+        {
+            var result = await service.SetItemsAsync(id, request, ct);
+            return Ok(result);
+        }
+        catch (KeyNotFoundException) { return NotFound(); }
+        catch (InvalidOperationException ex) { return BadRequest(new { error = ex.Message }); }
+    }
+
+    [HttpPost("{id:guid}/confirm-dispatch")]
+    [Authorize(Policy = "loading.dispatch")]
+    public async Task<IActionResult> ConfirmDispatch(Guid id, CancellationToken ct)
+    {
+        var userId = currentUser.UserId ?? throw new UnauthorizedAccessException();
+        try
+        {
+            var result = await service.ConfirmDispatchAsync(id, userId, ct);
+            return Ok(result);
+        }
+        catch (KeyNotFoundException) { return NotFound(); }
+        catch (InvalidOperationException ex) { return BadRequest(new { error = ex.Message }); }
+    }
+
+    [HttpPut("{id:guid}/receipt-items")]
+    [Authorize(Policy = "loading.receive")]
+    public async Task<IActionResult> SetReceiptItems(Guid id, SetReceiptItemsRequest request, CancellationToken ct)
+    {
+        try
+        {
+            var result = await service.SetReceiptItemsAsync(id, request, ct);
+            return Ok(result);
+        }
+        catch (KeyNotFoundException) { return NotFound(); }
+        catch (InvalidOperationException ex) { return BadRequest(new { error = ex.Message }); }
+    }
+
+    [HttpPost("{id:guid}/confirm-receipt")]
+    [Authorize(Policy = "loading.receive")]
+    public async Task<IActionResult> ConfirmReceipt(Guid id, ConfirmReceiptRequest request, CancellationToken ct)
+    {
+        var userId = currentUser.UserId ?? throw new UnauthorizedAccessException();
+        try
+        {
+            var result = await service.ConfirmReceiptAsync(id, request, userId, ct);
+            return Ok(result);
+        }
+        catch (KeyNotFoundException) { return NotFound(); }
+        catch (InvalidOperationException ex) { return BadRequest(new { error = ex.Message }); }
+    }
+
+    [HttpPost("{id:guid}/resolve")]
+    [Authorize(Policy = "loading.resolve")]
+    public async Task<IActionResult> Resolve(Guid id, ResolveDiscrepancyRequest request, CancellationToken ct)
+    {
+        var userId = currentUser.UserId ?? throw new UnauthorizedAccessException();
+        try
+        {
+            var result = await service.ResolveAsync(id, request, userId, ct);
+            return Ok(result);
+        }
+        catch (KeyNotFoundException) { return NotFound(); }
+        catch (InvalidOperationException ex) { return BadRequest(new { error = ex.Message }); }
+    }
+}

Distribution/Features/LoadingEvent/LoadingSheetDTOs.cs

@@ -0,0 +1,37 @@
+using Distribution.Models;
+
+namespace Distribution.Features.LoadingEvent;
+
+public record LoadingSheetResponse(
+    Guid Id,
+    Guid FK_RideId,
+    Guid FK_SourceWarehouseId,
+    string WarehouseName,
+    LoadingSheetStatus Status,
+    DateTime? DispatchConfirmedAt,
+    Guid? DispatchConfirmedBy,
+    DateTime? ReceiptConfirmedAt,
+    Guid? ReceiptConfirmedBy,
+    DateTime CreatedAt,
+    List<LoadingSheetItemResponse> Items);
+
+public record LoadingSheetItemResponse(
+    Guid Id,
+    Guid FK_ItemId,
+    string ItemName,
+    decimal QuantityDispatched,
+    decimal? QuantityReceived,
+    decimal? QuantityResolved);
+
+public record CreateLoadingSheetRequest(Guid FK_RideId);
+
+public record SetItemsRequest(List<SetItemInput> Items);
+public record SetItemInput(Guid FK_ItemId, decimal Quantity);
+
+public record SetReceiptItemsRequest(List<ReceiptItemInput> Items);
+public record ReceiptItemInput(Guid FK_ItemId, decimal QuantityReceived);
+
+public record ConfirmReceiptRequest(int Meterstart);
+
+public record ResolveDiscrepancyRequest(List<ResolveItemInput> Items, int Meterstart);
+public record ResolveItemInput(Guid FK_ItemId, decimal QuantityResolved);

Distribution/Features/LoadingEvent/LoadingSheetRepository.cs

@@ -0,0 +1,60 @@
+using Distribution.Data;
+using Distribution.Models;
+using Microsoft.EntityFrameworkCore;
+
+namespace Distribution.Features.LoadingEvent;
+
+public class LoadingSheetRepository(AppDBContext context) : ILoadingSheetRepository
+{
+    public async Task<LoadingSheet?> GetByIdAsync(Guid id) =>
+        await context.LoadingSheets
+            .Include(s => s.SourceWarehouse)
+            .Include(s => s.Items).ThenInclude(i => i.Item)
+            .FirstOrDefaultAsync(s => s.Id == id);
+
+    public async Task<LoadingSheet?> GetActiveByRideIdAsync(Guid rideId) =>
+        await context.LoadingSheets
+            .FirstOrDefaultAsync(s =>
+                s.FK_RideId == rideId &&
+                s.Status != LoadingSheetStatus.ReceiptConfirmed &&
+                s.Status != LoadingSheetStatus.Resolved);
+
+    public async Task<List<LoadingSheet>> GetAllAsync(Guid? rideId, LoadingSheetStatus? status, int page, int pageSize) =>
+        await context.LoadingSheets
+            .Include(s => s.SourceWarehouse)
+            .Where(s =>
+                (rideId == null || s.FK_RideId == rideId) &&
+                (status == null || s.Status == status))
+            .OrderByDescending(s => s.CreatedAt)
+            .Skip((page - 1) * pageSize)
+            .Take(pageSize)
+            .ToListAsync();
+
+    public async Task<int> GetCountAsync(Guid? rideId, LoadingSheetStatus? status) =>
+        await context.LoadingSheets
+            .CountAsync(s =>
+                (rideId == null || s.FK_RideId == rideId) &&
+                (status == null || s.Status == status));
+
+    public async Task<List<(Guid ItemId, decimal TotalQty)>> GetAggregatedOrderItemsByRouteIdAsync(Guid routeId)
+    {
+        var groups = await context.OrderItems
+            .Where(oi => oi.IsActive && oi.Order.IsActive && oi.Order.Store.FK_RouteId == routeId)
+            .GroupBy(oi => oi.FK_ItemId)
+            .Select(g => new { ItemId = g.Key, TotalQty = g.Sum(oi => (decimal)oi.Quantity) })
+            .ToListAsync();
+        return groups.Select(x => (x.ItemId, x.TotalQty)).ToList();
+    }
+
+    public async Task AddAsync(LoadingSheet sheet) =>
+        await context.LoadingSheets.AddAsync(sheet);
+
+    public void Update(LoadingSheet sheet) =>
+        context.LoadingSheets.Update(sheet);
+
+    public void RemoveItems(IEnumerable<LoadingSheetItem> items) =>
+        context.LoadingSheetItems.RemoveRange(items);
+
+    public async Task AddItemsAsync(IEnumerable<LoadingSheetItem> items) =>
+        await context.LoadingSheetItems.AddRangeAsync(items);
+}

Distribution/Features/LoadingEvent/LoadingSheetService.cs

@@ -0,0 +1,284 @@
+using Distribution.Features.Ride;
+using Distribution.Features.Stock;
+using Distribution.Infra.UoW;
+using Distribution.Models;
+
+namespace Distribution.Features.LoadingEvent;
+
+public class LoadingSheetService(
+    ILoadingSheetRepository repo,
+    IRideRepository rideRepo,
+    IStockRepository stockRepo,
+    IUnitOfWork uow)
+{
+    public async Task<PagedResponse<LoadingSheetResponse>> GetAllAsync(Guid? rideId, LoadingSheetStatus? status, int page, int pageSize)
+    {
+        var total = await repo.GetCountAsync(rideId, status);
+        var items = await repo.GetAllAsync(rideId, status, page, pageSize);
+        return new PagedResponse<LoadingSheetResponse>(page, pageSize, total, items.Select(ToResponse).ToList());
+    }
+
+    public async Task<LoadingSheetResponse?> GetByIdAsync(Guid id)
+    {
+        var sheet = await repo.GetByIdAsync(id);
+        return sheet is null ? null : ToResponse(sheet);
+    }
+
+    public async Task<LoadingSheetResponse> CreateAsync(CreateLoadingSheetRequest request, CancellationToken ct = default)
+    {
+        var ride = await rideRepo.GetByIdAsync(request.FK_RideId)
+            ?? throw new KeyNotFoundException("Ride not found");
+
+        if (ride.Status != RideStatus.Open)
+            throw new InvalidOperationException("A loading sheet can only be created for an Open ride");
+
+        var existing = await repo.GetActiveByRideIdAsync(request.FK_RideId);
+        if (existing is not null)
+            throw new InvalidOperationException("This ride already has an active loading sheet");
+
+        var sheet = new LoadingSheet
+        {
+            FK_RideId = ride.Id,
+            FK_SourceWarehouseId = ride.FK_SourceWarehouseId,
+            Status = LoadingSheetStatus.Pending
+        };
+
+        if (ride.RideType == RideType.Delivery)
+        {
+            var orderItems = await repo.GetAggregatedOrderItemsByRouteIdAsync(ride.FK_RouteId);
+            foreach (var (itemId, qty) in orderItems)
+                sheet.Items.Add(new LoadingSheetItem { FK_ItemId = itemId, QuantityDispatched = qty });
+        }
+
+        await uow.BeginAsync(ct);
+        try
+        {
+            await repo.AddAsync(sheet);
+            await uow.CommitAsync(ct);
+        }
+        catch { await uow.RollbackAsync(ct); throw; }
+
+        var saved = await repo.GetByIdAsync(sheet.Id);
+        return ToResponse(saved!);
+    }
+
+    public async Task<LoadingSheetResponse> SetItemsAsync(Guid id, SetItemsRequest request, CancellationToken ct = default)
+    {
+        var sheet = await repo.GetByIdAsync(id)
+            ?? throw new KeyNotFoundException("Loading sheet not found");
+
+        if (sheet.Status != LoadingSheetStatus.Pending)
+            throw new InvalidOperationException("Items can only be changed while the sheet is Pending");
+
+        await uow.BeginAsync(ct);
+        try
+        {
+            repo.RemoveItems(sheet.Items);
+            await repo.AddItemsAsync(request.Items.Select(i => new LoadingSheetItem
+            {
+                FK_LoadingSheetId = sheet.Id,
+                FK_ItemId = i.FK_ItemId,
+                QuantityDispatched = i.Quantity
+            }));
+            await uow.CommitAsync(ct);
+        }
+        catch { await uow.RollbackAsync(ct); throw; }
+
+        var saved = await repo.GetByIdAsync(sheet.Id);
+        return ToResponse(saved!);
+    }
+
+    public async Task<LoadingSheetResponse> ConfirmDispatchAsync(Guid id, Guid userId, CancellationToken ct = default)
+    {
+        var sheet = await repo.GetByIdAsync(id)
+            ?? throw new KeyNotFoundException("Loading sheet not found");
+
+        if (sheet.Status != LoadingSheetStatus.Pending)
+            throw new InvalidOperationException($"Cannot confirm dispatch for a sheet in {sheet.Status} status");
+
+        if (!sheet.Items.Any(i => i.QuantityDispatched > 0))
+            throw new InvalidOperationException("Sheet must have at least one item with quantity greater than zero");
+
+        sheet.Status = LoadingSheetStatus.DispatchConfirmed;
+        sheet.DispatchConfirmedAt = DateTime.Now;
+        sheet.DispatchConfirmedBy = userId;
+
+        await uow.BeginAsync(ct);
+        try { repo.Update(sheet); await uow.CommitAsync(ct); }
+        catch { await uow.RollbackAsync(ct); throw; }
+
+        return ToResponse(sheet);
+    }
+
+    public async Task<LoadingSheetResponse> SetReceiptItemsAsync(Guid id, SetReceiptItemsRequest request, CancellationToken ct = default)
+    {
+        var sheet = await repo.GetByIdAsync(id)
+            ?? throw new KeyNotFoundException("Loading sheet not found");
+
+        if (sheet.Status != LoadingSheetStatus.DispatchConfirmed)
+            throw new InvalidOperationException("Receipt quantities can only be set after dispatch is confirmed");
+
+        foreach (var input in request.Items)
+        {
+            var item = sheet.Items.FirstOrDefault(i => i.FK_ItemId == input.FK_ItemId)
+                ?? throw new InvalidOperationException($"Item {input.FK_ItemId} is not on this loading sheet");
+            item.QuantityReceived = input.QuantityReceived;
+        }
+
+        await uow.BeginAsync(ct);
+        try { repo.Update(sheet); await uow.CommitAsync(ct); }
+        catch { await uow.RollbackAsync(ct); throw; }
+
+        return ToResponse(sheet);
+    }
+
+    public async Task<LoadingSheetResponse> ConfirmReceiptAsync(Guid id, ConfirmReceiptRequest request, Guid userId, CancellationToken ct = default)
+    {
+        var sheet = await repo.GetByIdAsync(id)
+            ?? throw new KeyNotFoundException("Loading sheet not found");
+
+        if (sheet.Status != LoadingSheetStatus.DispatchConfirmed)
+            throw new InvalidOperationException($"Cannot confirm receipt for a sheet in {sheet.Status} status");
+
+        if (sheet.Items.Any(i => !i.QuantityReceived.HasValue))
+            throw new InvalidOperationException("All items must have a received quantity before confirming receipt");
+
+        var ride = await rideRepo.GetByIdAsync(sheet.FK_RideId)
+            ?? throw new KeyNotFoundException("Ride not found");
+
+        var hasDiscrepancy = sheet.Items.Any(i => i.QuantityReceived != i.QuantityDispatched);
+
+        await uow.BeginAsync(ct);
+        try
+        {
+            if (hasDiscrepancy)
+            {
+                sheet.Status = LoadingSheetStatus.DiscrepancyFlagged;
+            }
+            else
+            {
+                sheet.Status = LoadingSheetStatus.ReceiptConfirmed;
+                sheet.ReceiptConfirmedAt = DateTime.Now;
+                sheet.ReceiptConfirmedBy = userId;
+
+                var lines = sheet.Items.Select(i => (i.FK_ItemId, i.QuantityReceived!.Value)).ToList();
+                await ApplyLoadMovementsAsync(sheet, ride.FK_VehicleId, lines, userId);
+
+                ride.Status = RideStatus.Active;
+                ride.ActivatedAt = DateTime.Now;
+                ride.Meterstart = request.Meterstart;
+                rideRepo.Update(ride);
+            }
+
+            repo.Update(sheet);
+            await uow.CommitAsync(ct);
+        }
+        catch { await uow.RollbackAsync(ct); throw; }
+
+        return ToResponse(sheet);
+    }
+
+    public async Task<LoadingSheetResponse> ResolveAsync(Guid id, ResolveDiscrepancyRequest request, Guid userId, CancellationToken ct = default)
+    {
+        var sheet = await repo.GetByIdAsync(id)
+            ?? throw new KeyNotFoundException("Loading sheet not found");
+
+        if (sheet.Status != LoadingSheetStatus.DiscrepancyFlagged)
+            throw new InvalidOperationException($"Cannot resolve a sheet in {sheet.Status} status");
+
+        foreach (var input in request.Items)
+        {
+            var item = sheet.Items.FirstOrDefault(i => i.FK_ItemId == input.FK_ItemId)
+                ?? throw new InvalidOperationException($"Item {input.FK_ItemId} is not on this loading sheet");
+            if (input.QuantityResolved < 0)
+                throw new InvalidOperationException("Resolved quantity cannot be negative");
+            item.QuantityResolved = input.QuantityResolved;
+        }
+
+        if (sheet.Items.Any(i => !i.QuantityResolved.HasValue))
+            throw new InvalidOperationException("All items must have a resolved quantity");
+
+        var ride = await rideRepo.GetByIdAsync(sheet.FK_RideId)
+            ?? throw new KeyNotFoundException("Ride not found");
+
+        sheet.Status = LoadingSheetStatus.Resolved;
+        sheet.ReceiptConfirmedAt = DateTime.Now;
+        sheet.ReceiptConfirmedBy = userId;
+
+        var lines = sheet.Items.Select(i => (i.FK_ItemId, i.QuantityResolved!.Value)).ToList();
+
+        await uow.BeginAsync(ct);
+        try
+        {
+            await ApplyLoadMovementsAsync(sheet, ride.FK_VehicleId, lines, userId);
+
+            ride.Status = RideStatus.Active;
+            ride.ActivatedAt = DateTime.Now;
+            ride.Meterstart = request.Meterstart;
+            rideRepo.Update(ride);
+
+            repo.Update(sheet);
+            await uow.CommitAsync(ct);
+        }
+        catch { await uow.RollbackAsync(ct); throw; }
+
+        return ToResponse(sheet);
+    }
+
+    private async Task ApplyLoadMovementsAsync(LoadingSheet sheet, Guid vehicleId, List<(Guid ItemId, decimal Qty)> lines, Guid userId)
+    {
+        foreach (var (itemId, qty) in lines.Where(l => l.Qty > 0))
+        {
+            var warehouseBalance = await stockRepo.GetBalanceAsync(itemId, sheet.FK_SourceWarehouseId)
+                ?? throw new InvalidOperationException($"No stock found in warehouse for item {itemId}");
+            if (warehouseBalance.Quantity < qty)
+                throw new InvalidOperationException($"Insufficient warehouse stock for item {itemId}");
+
+            warehouseBalance.Quantity -= qty;
+            warehouseBalance.UpdatedAt = DateTime.Now;
+            stockRepo.UpdateBalance(warehouseBalance);
+
+            var vehicleBalance = await stockRepo.GetBalanceAsync(itemId, vehicleId);
+            if (vehicleBalance is null)
+            {
+                await stockRepo.AddBalanceAsync(new StockBalance
+                {
+                    FK_ItemId = itemId,
+                    LocationId = vehicleId,
+                    LocationType = LocationType.Vehicle,
+                    Quantity = qty
+                });
+            }
+            else
+            {
+                vehicleBalance.Quantity += qty;
+                vehicleBalance.UpdatedAt = DateTime.Now;
+                stockRepo.UpdateBalance(vehicleBalance);
+            }
+
+            await stockRepo.AddMovementAsync(new StockMovement
+            {
+                FK_ItemId = itemId,
+                FromLocationId = sheet.FK_SourceWarehouseId,
+                FromLocationType = LocationType.Warehouse,
+                ToLocationId = vehicleId,
+                ToLocationType = LocationType.Vehicle,
+                Quantity = qty,
+                Type = MovementType.Load,
+                ReferenceId = sheet.Id,
+                CreatedBy = userId
+            });
+        }
+    }
+
+    private static LoadingSheetResponse ToResponse(LoadingSheet s) =>
+        new(s.Id, s.FK_RideId, s.FK_SourceWarehouseId,
+            s.SourceWarehouse?.Name ?? string.Empty,
+            s.Status,
+            s.DispatchConfirmedAt, s.DispatchConfirmedBy,
+            s.ReceiptConfirmedAt, s.ReceiptConfirmedBy,
+            s.CreatedAt,
+            s.Items.Select(i => new LoadingSheetItemResponse(
+                i.Id, i.FK_ItemId, i.Item?.Name ?? string.Empty,
+                i.QuantityDispatched, i.QuantityReceived, i.QuantityResolved)).ToList());
+}

Distribution/Features/Ride/RideService.cs

@@ -39,7 +39,7 @@ public class RideService(
         var vehicle = await vehicleRepo.GetByIdAsync(request.FK_VehicleId)
             ?? throw new InvalidOperationException("Vehicle not found");
 
-        var sourceWarehouseId = vehicle.FK_DefaultWarehouseId ?? request.FK_SourceWarehouseId;
+        var sourceWarehouseId = vehicle.DefaultWarehouseId ?? request.FK_SourceWarehouseId;
         if (!sourceWarehouseId.HasValue)
             throw new InvalidOperationException("Source warehouse is required for this vehicle");