Add FlatPaymentController with RESTful payment endpoints

Introduced FlatPaymentController under Distribution.Features.Payment, providing GET and POST endpoints at /api/payments. Supports listing, retrieving, and creating payments with filtering and error handling. Business logic is delegated to PaymentService.

Distribution/Features/DeliveryRide/DeliveryTaskController.cs

@@ -19,6 +19,7 @@ public class DeliveryTaskController(DeliveryTaskService service) : ControllerBas
     }
 
     [HttpGet("rides/{rideId:guid}/tasks")]
+    [HttpGet("rides/{rideId:guid}/delivery-tasks")]
     public async Task<IActionResult> GetByRide(Guid rideId)
     {
         var result = await service.GetByRideIdAsync(rideId);

Distribution/Features/DriverComplianceConfig/DriverComplianceConfigController.cs

@@ -1,24 +0,0 @@
-using Distribution.Infra.Authorization;
-using Microsoft.AspNetCore.Mvc;
-
-namespace Distribution.Features.DriverComplianceConfig;
-
-[ApiController]
-[Route("api/driver-compliance-config")]
-public class DriverComplianceConfigController(DriverComplianceConfigService service, ICurrentUserService currentUser) : ControllerBase
-{
-    [HttpGet]
-    public async Task<IActionResult> Get()
-    {
-        var result = await service.GetAsync();
-        return result is null ? NoContent() : Ok(result);
-    }
-
-    [HttpPut]
-    public async Task<IActionResult> Upsert(UpdateDriverComplianceConfigRequest request, CancellationToken ct)
-    {
-        var userId = currentUser.UserId ?? throw new UnauthorizedAccessException();
-        var result = await service.UpsertAsync(request, userId, ct);
-        return Ok(result);
-    }
-}

Distribution/Features/DriverProfile/DriverProfileController.cs

@@ -1,10 +1,15 @@
-using Microsoft.AspNetCore.Mvc;
+using Distribution.Features.DriverComplianceConfig;
+using Distribution.Infra.Authorization;
+using Microsoft.AspNetCore.Mvc;
 
 namespace Distribution.Features.DriverProfile;
 
 [ApiController]
 [Route("api/driver-profiles")]
-public class DriverProfileController(DriverProfileService service) : ControllerBase
+public class DriverProfileController(
+    DriverProfileService service,
+    DriverComplianceConfigService complianceService,
+    ICurrentUserService currentUser) : ControllerBase
 {
     [HttpGet]
     public async Task<IActionResult> GetAll([FromQuery] int page = 1, [FromQuery] int pageSize = 20)
@@ -23,8 +28,19 @@ public class DriverProfileController(DriverProfileService service) : ControllerB
     [HttpPost]
     public async Task<IActionResult> Create(CreateDriverProfileRequest request, CancellationToken ct)
     {
-        var result = await service.CreateAsync(request, ct);
-        return CreatedAtAction(nameof(GetById), new { id = result.Id }, result);
+        try
+        {
+            var result = await service.CreateAsync(request, ct);
+            return CreatedAtAction(nameof(GetById), new { id = result.Id }, result);
+        }
+        catch (KeyNotFoundException ex)
+        {
+            return NotFound(new { error = ex.Message });
+        }
+        catch (InvalidOperationException ex)
+        {
+            return Conflict(new { error = ex.Message });
+        }
     }
 
     [HttpPut("{id:guid}")]
@@ -40,4 +56,19 @@ public class DriverProfileController(DriverProfileService service) : ControllerB
         var success = await service.DeactivateAsync(id, ct);
         return success ? NoContent() : NotFound();
     }
+
+    [HttpGet("compliance")]
+    public async Task<IActionResult> GetCompliance()
+    {
+        var result = await complianceService.GetAsync();
+        return result is null ? NoContent() : Ok(result);
+    }
+
+    [HttpPut("compliance")]
+    public async Task<IActionResult> UpsertCompliance(UpdateDriverComplianceConfigRequest request, CancellationToken ct)
+    {
+        var userId = currentUser.UserId ?? throw new UnauthorizedAccessException();
+        var result = await complianceService.UpsertAsync(request, userId, ct);
+        return Ok(result);
+    }
 }

Distribution/Features/DriverProfile/DriverProfileDTOs.cs

@@ -11,7 +11,7 @@ public record DriverProfileResponse(
     DateTime CreatedAt);
 
 public record CreateDriverProfileRequest(
-    Guid FK_UserId,
+    Guid UserId,
     string LicenseNumber,
     DateTime LicenseExpiry,
     DateTime MedicalClearanceExpiry);

Distribution/Features/DriverProfile/DriverProfileService.cs

@@ -1,9 +1,10 @@
 using Distribution.Features.Stock;
+using Distribution.Features.User;
 using Distribution.Infra.UoW;
 
 namespace Distribution.Features.DriverProfile;
 
-public class DriverProfileService(IDriverProfileRepository repo, IUnitOfWork uow)
+public class DriverProfileService(IDriverProfileRepository repo, IUnitOfWork uow, IUserRepository userRepo)
 {
     public async Task<PagedResponse<DriverProfileResponse>> GetAllAsync(int page, int pageSize)
     {
@@ -21,13 +22,17 @@ public class DriverProfileService(IDriverProfileRepository repo, IUnitOfWork uow
 
     public async Task<DriverProfileResponse> CreateAsync(CreateDriverProfileRequest request, CancellationToken ct = default)
     {
-        var existing = await repo.GetByUserIdAsync(request.FK_UserId);
+        var user = await userRepo.GetByIdAsync(request.UserId);
+        if (user is null)
+            throw new KeyNotFoundException($"User {request.UserId} not found");
+
+        var existing = await repo.GetByUserIdAsync(request.UserId);
         if (existing is not null && existing.IsActive)
             throw new InvalidOperationException("An active driver profile already exists for this user");
 
         var profile = new global::Distribution.Models.DriverProfile
         {
-            FK_UserId = request.FK_UserId,
+            FK_UserId = request.UserId,
             LicenseNumber = request.LicenseNumber,
             LicenseExpiry = request.LicenseExpiry,
             MedicalClearanceExpiry = request.MedicalClearanceExpiry

Distribution/Features/Grn/GrnController.cs

@@ -6,6 +6,16 @@ namespace Distribution.Features.Grn;
 [ApiController]
 public class GrnController(GrnService service, ICurrentUserService currentUser) : ControllerBase
 {
+    [HttpGet("api/goods-receipts")]
+    public async Task<IActionResult> GetAll(
+        [FromQuery] Guid? purchaseOrderId,
+        [FromQuery] int page = 1,
+        [FromQuery] int pageSize = 20)
+    {
+        var result = await service.GetAllAsync(purchaseOrderId, page, pageSize);
+        return Ok(result);
+    }
+
     [HttpGet("api/goods-receipts/{id:guid}")]
     public async Task<IActionResult> GetById(Guid id)
     {
@@ -13,6 +23,19 @@ public class GrnController(GrnService service, ICurrentUserService currentUser)
         return result is null ? NotFound() : Ok(result);
     }
 
+    [HttpPost("api/goods-receipts")]
+    public async Task<IActionResult> CreateFlat(CreateFlatGrnRequest request, CancellationToken ct)
+    {
+        var userId = currentUser.UserId ?? throw new UnauthorizedAccessException();
+        try
+        {
+            var inner = new CreateGrnRequest(request.WarehouseId, request.Items);
+            var result = await service.CreateAsync(request.PurchaseOrderId, inner, userId, ct);
+            return CreatedAtAction(nameof(GetById), new { id = result.Id }, result);
+        }
+        catch (InvalidOperationException ex) { return Conflict(new { error = ex.Message }); }
+    }
+
     [HttpGet("api/purchase-orders/{id:guid}/goods-receipts")]
     public async Task<IActionResult> GetByPurchaseOrder(Guid id) =>
         Ok(await service.GetByPurchaseOrderIdAsync(id));

Distribution/Features/Grn/GrnDTOs.cs

@@ -4,6 +4,8 @@ public record GrnItemRequest(Guid PurchaseOrderItemId, int AcceptedQuantity, int
 
 public record CreateGrnRequest(Guid WarehouseId, List<GrnItemRequest> Items);
 
+public record CreateFlatGrnRequest(Guid PurchaseOrderId, Guid WarehouseId, List<GrnItemRequest> Items);
+
 public record GrnItemResponse(
     Guid Id,
     Guid PurchaseOrderItemId,

Distribution/Features/Grn/GrnRepository.cs

@@ -11,6 +11,21 @@ public class GrnRepository(AppDBContext context) : IGrnRepository
             .Include(gr => gr.Items).ThenInclude(i => i.PurchaseOrderItem).ThenInclude(poi => poi.Item)
             .FirstOrDefaultAsync(gr => gr.Id == id);
 
+    public async Task<List<Models.GoodsReceipt>> GetAllAsync(Guid? purchaseOrderId, int page, int pageSize) =>
+        await context.GoodsReceipts
+            .Include(gr => gr.Warehouse)
+            .Include(gr => gr.Items).ThenInclude(i => i.PurchaseOrderItem).ThenInclude(poi => poi.Item)
+            .Where(gr => gr.IsActive && (purchaseOrderId == null || gr.FK_PurchaseOrderId == purchaseOrderId))
+            .OrderByDescending(gr => gr.ReceivedAt)
+            .Skip((page - 1) * pageSize)
+            .Take(pageSize)
+            .ToListAsync();
+
+    public async Task<int> GetCountAsync(Guid? purchaseOrderId) =>
+        await context.GoodsReceipts
+            .Where(gr => gr.IsActive && (purchaseOrderId == null || gr.FK_PurchaseOrderId == purchaseOrderId))
+            .CountAsync();
+
     public async Task<List<Models.GoodsReceipt>> GetByPurchaseOrderIdAsync(Guid purchaseOrderId) =>
         await context.GoodsReceipts
             .Include(gr => gr.Warehouse)

Distribution/Features/Grn/GrnService.cs

@@ -19,6 +19,13 @@ public class GrnService(
         new(gr.Id, gr.FK_PurchaseOrderId, gr.FK_ReceivedByUserId, gr.FK_WarehouseId, gr.Warehouse?.Name ?? string.Empty,
             gr.ReceivedAt, gr.CreatedAt, gr.Items.Where(i => i.IsActive).Select(MapItem).ToList());
 
+    public async Task<PagedResponse<GrnResponse>> GetAllAsync(Guid? purchaseOrderId, int page, int pageSize)
+    {
+        var total = await repo.GetCountAsync(purchaseOrderId);
+        var items = await repo.GetAllAsync(purchaseOrderId, page, pageSize);
+        return new PagedResponse<GrnResponse>(page, pageSize, total, items.Select(Map).ToList());
+    }
+
     public async Task<GrnResponse?> GetByIdAsync(Guid id)
     {
         var gr = await repo.GetByIdAsync(id);

Distribution/Features/Grn/IGrnRepository.cs

@@ -3,6 +3,8 @@ namespace Distribution.Features.Grn;
 public interface IGrnRepository
 {
     Task<Models.GoodsReceipt?> GetByIdAsync(Guid id);
+    Task<List<Models.GoodsReceipt>> GetAllAsync(Guid? purchaseOrderId, int page, int pageSize);
+    Task<int> GetCountAsync(Guid? purchaseOrderId);
     Task<List<Models.GoodsReceipt>> GetByPurchaseOrderIdAsync(Guid purchaseOrderId);
     Task AddAsync(Models.GoodsReceipt entity);
 

Distribution/Features/LoadingEvent/LoadingSheetController.cs

@@ -100,4 +100,43 @@ public class LoadingSheetController(LoadingSheetService service, ICurrentUserSer
         catch (KeyNotFoundException) { return NotFound(); }
         catch (InvalidOperationException ex) { return BadRequest(new { error = ex.Message }); }
     }
+
+    [HttpPatch("{id:guid}/dispatch")]
+    public async Task<IActionResult> PatchDispatch(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 }); }
+    }
+
+    [HttpPatch("{id:guid}/receipt")]
+    public async Task<IActionResult> PatchReceipt(Guid id, PatchReceiptRequest request, CancellationToken ct)
+    {
+        var userId = currentUser.UserId ?? throw new UnauthorizedAccessException();
+        try
+        {
+            var result = await service.PatchReceiptAsync(id, request.Items, userId, ct);
+            return Ok(result);
+        }
+        catch (KeyNotFoundException) { return NotFound(); }
+        catch (InvalidOperationException ex) { return BadRequest(new { error = ex.Message }); }
+    }
+
+    [HttpPatch("{id:guid}/resolve")]
+    public async Task<IActionResult> PatchResolve(Guid id, CancellationToken ct)
+    {
+        var userId = currentUser.UserId ?? throw new UnauthorizedAccessException();
+        try
+        {
+            var result = await service.PatchResolveAsync(id, userId, ct);
+            return Ok(result);
+        }
+        catch (KeyNotFoundException) { return NotFound(); }
+        catch (InvalidOperationException ex) { return BadRequest(new { error = ex.Message }); }
+    }
 }

Distribution/Features/LoadingEvent/LoadingSheetDTOs.cs

@@ -35,3 +35,7 @@ public record ConfirmReceiptRequest(int Meterstart);
 
 public record ResolveDiscrepancyRequest(List<ResolveItemInput> Items, int Meterstart);
 public record ResolveItemInput(Guid FK_ItemId, decimal QuantityResolved);
+
+// Combined PATCH endpoints used by the frontend
+public record PatchReceiptItemInput(Guid ItemId, decimal QuantityReceived);
+public record PatchReceiptRequest(List<PatchReceiptItemInput> Items);

Distribution/Features/LoadingEvent/LoadingSheetService.cs

@@ -225,6 +225,98 @@ public class LoadingSheetService(
         return ToResponse(sheet);
     }
 
+    public async Task<LoadingSheetResponse> PatchReceiptAsync(Guid id, List<PatchReceiptItemInput> items, 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 set receipt for a sheet in {sheet.Status} status");
+
+        foreach (var input in items)
+        {
+            var sheetItem = sheet.Items.FirstOrDefault(i => i.FK_ItemId == input.ItemId)
+                ?? throw new InvalidOperationException($"Item {input.ItemId} is not on this loading sheet");
+            sheetItem.QuantityReceived = input.QuantityReceived;
+        }
+
+        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 = 0;
+                rideRepo.Update(ride);
+            }
+
+            repo.Update(sheet);
+            await uow.CommitAsync(ct);
+        }
+        catch { await uow.RollbackAsync(ct); throw; }
+
+        return ToResponse(sheet);
+    }
+
+    public async Task<LoadingSheetResponse> PatchResolveAsync(Guid id, 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 item in sheet.Items)
+        {
+            if (!item.QuantityReceived.HasValue)
+                throw new InvalidOperationException($"Item {item.FK_ItemId} has no received quantity to resolve from");
+            item.QuantityResolved = item.QuantityReceived.Value;
+        }
+
+        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 = 0;
+            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))

Distribution/Features/Payment/FlatPaymentController.cs

@@ -0,0 +1,38 @@
+using Microsoft.AspNetCore.Mvc;
+
+namespace Distribution.Features.Payment;
+
+[ApiController]
+[Route("api/payments")]
+public class FlatPaymentController(PaymentService service) : ControllerBase
+{
+    [HttpGet]
+    public async Task<IActionResult> GetAll(
+        [FromQuery] Guid? storeId,
+        [FromQuery] Guid? saleId,
+        [FromQuery] int page = 1,
+        [FromQuery] int pageSize = 20)
+    {
+        var result = await service.GetAllAsync(storeId, saleId, page, pageSize);
+        return Ok(result);
+    }
+
+    [HttpGet("{id:guid}")]
+    public async Task<IActionResult> GetById(Guid id)
+    {
+        var result = await service.GetByIdAsync(id);
+        return result is null ? NotFound() : Ok(result);
+    }
+
+    [HttpPost]
+    public async Task<IActionResult> Create(CreateFlatPaymentRequest request, CancellationToken ct)
+    {
+        try
+        {
+            var inner = new CreatePaymentRequest(request.Amount, request.Method);
+            var result = await service.CreateAsync(request.SaleId, inner, ct);
+            return result is null ? NotFound(new { error = "Sale not found or access denied" }) : Ok(result);
+        }
+        catch (InvalidOperationException ex) { return BadRequest(new { error = ex.Message }); }
+    }
+}

Distribution/Features/Payment/IPaymentRepository.cs

@@ -4,6 +4,9 @@ namespace Distribution.Features.Payment;
 
 public interface IPaymentRepository
 {
+    Task<Models.Payment?> GetByIdAsync(Guid id);
+    Task<List<Models.Payment>> GetAllAsync(Guid? storeId, Guid? saleId, int page, int pageSize);
+    Task<int> GetCountAsync(Guid? storeId, Guid? saleId);
     Task<List<Models.Payment>> GetBySaleIdAsync(Guid saleId);
     Task AddAsync(Models.Payment payment);
 }

Distribution/Features/Payment/PaymentDTOs.cs

@@ -4,6 +4,8 @@ namespace Distribution.Features.Payment;
 
 public record CreatePaymentRequest(decimal Amount, PaymentMethod Method);
 
+public record CreateFlatPaymentRequest(Guid SaleId, decimal Amount, PaymentMethod Method);
+
 public record PaymentResponse(
     Guid Id,
     Guid SaleId,

Distribution/Features/Payment/PaymentRepository.cs

@@ -6,6 +6,26 @@ namespace Distribution.Features.Payment;
 
 public class PaymentRepository(AppDBContext context) : IPaymentRepository
 {
+    public async Task<Models.Payment?> GetByIdAsync(Guid id) =>
+        await context.Payments.FirstOrDefaultAsync(p => p.Id == id && p.IsActive);
+
+    public async Task<List<Models.Payment>> GetAllAsync(Guid? storeId, Guid? saleId, int page, int pageSize) =>
+        await context.Payments
+            .Where(p => p.IsActive
+                && (storeId == null || p.FK_StoreId == storeId)
+                && (saleId == null || p.FK_SaleId == saleId))
+            .OrderByDescending(p => p.CollectedAt)
+            .Skip((page - 1) * pageSize)
+            .Take(pageSize)
+            .ToListAsync();
+
+    public async Task<int> GetCountAsync(Guid? storeId, Guid? saleId) =>
+        await context.Payments
+            .Where(p => p.IsActive
+                && (storeId == null || p.FK_StoreId == storeId)
+                && (saleId == null || p.FK_SaleId == saleId))
+            .CountAsync();
+
     public async Task<List<Models.Payment>> GetBySaleIdAsync(Guid saleId) =>
         await context.Payments
             .Where(p => p.FK_SaleId == saleId && p.IsActive)

Distribution/Features/Payment/PaymentService.cs

@@ -1,4 +1,5 @@
 using Distribution.Features.Sale;
+using Distribution.Features.Stock;
 using Distribution.Infra.Authorization;
 using Distribution.Infra.UoW;
 using Distribution.Models;
@@ -14,6 +15,19 @@ public class PaymentService(
     private static PaymentResponse ToResponse(Models.Payment p) =>
         new(p.Id, p.FK_SaleId, p.FK_StoreId, p.Amount, p.Method, p.CollectedAt, p.CollectedBy, p.CreatedAt);
 
+    public async Task<PagedResponse<PaymentResponse>> GetAllAsync(Guid? storeId, Guid? saleId, int page, int pageSize)
+    {
+        var total = await repo.GetCountAsync(storeId, saleId);
+        var items = await repo.GetAllAsync(storeId, saleId, page, pageSize);
+        return new PagedResponse<PaymentResponse>(page, pageSize, total, items.Select(ToResponse).ToList());
+    }
+
+    public async Task<PaymentResponse?> GetByIdAsync(Guid id)
+    {
+        var payment = await repo.GetByIdAsync(id);
+        return payment is null ? null : ToResponse(payment);
+    }
+
     public async Task<List<PaymentResponse>?> GetBySaleIdAsync(Guid saleId)
     {
         var sale = await saleRepo.GetByIdAsync(saleId);

Distribution/Features/Ride/RideController.cs

@@ -59,6 +59,7 @@ public class RideController(RideService service, ICurrentUserService currentUser
         catch (InvalidOperationException ex) { return BadRequest(new { error = ex.Message }); }
     }
 
+    [HttpPatch("{id:guid}/activate")]
     [HttpPost("{id:guid}/activate")]
     public async Task<IActionResult> Activate(Guid id, ActivateRideRequest request, CancellationToken ct)
     {
@@ -71,6 +72,7 @@ public class RideController(RideService service, ICurrentUserService currentUser
         catch (InvalidOperationException ex) { return BadRequest(new { error = ex.Message }); }
     }
 
+    [HttpPatch("{id:guid}/close")]
     [HttpPost("{id:guid}/close")]
     public async Task<IActionResult> Close(Guid id, CloseRideRequest request, CancellationToken ct)
     {

Distribution/Features/Sale/SaleController.cs

@@ -33,4 +33,15 @@ public class SaleController(SaleService service) : ControllerBase
         var result = await service.CreateAsync(request, ct);
         return result is null ? Forbid() : CreatedAtAction(nameof(GetById), new { id = result.Id }, result);
     }
+
+    [HttpPatch("{id:guid}/cancel")]
+    public async Task<IActionResult> Cancel(Guid id, CancellationToken ct)
+    {
+        try
+        {
+            var result = await service.CancelAsync(id, ct);
+            return result is null ? NotFound() : Ok(result);
+        }
+        catch (InvalidOperationException ex) { return Conflict(new { error = ex.Message }); }
+    }
 }

Distribution/Features/Sale/SaleService.cs

@@ -119,6 +119,26 @@ public class SaleService(
         return result;
     }
 
+    public async Task<SaleResponse?> CancelAsync(Guid id, CancellationToken ct = default)
+    {
+        var sale = await repo.GetByIdAsync(id);
+        if (sale is null || !sale.IsActive) return null;
+        if (!await HasStoreScopeAsync(sale.FK_StoreId)) return null;
+        if (sale.Status == SaleStatus.Cancelled)
+            throw new InvalidOperationException("Sale is already cancelled");
+
+        sale.Status = SaleStatus.Cancelled;
+
+        await uow.BeginAsync(ct);
+        try { repo.Update(sale); await uow.CommitAsync(ct); }
+        catch { await uow.RollbackAsync(ct); throw; }
+
+        var order = await repo.GetOrderBySaleIdAsync(id);
+        if (order is null) return null;
+        var items = await orderRepo.GetItemsByOrderIdAsync(order.Id);
+        return ToResponse(sale, order, items);
+    }
+
     public async Task<SaleResponse?> CreateAsync(CreateSaleRequest request, CancellationToken ct = default)
     {
         if (!await HasStoreScopeAsync(request.StoreId)) return null;

Distribution/Features/Store/StoreController.cs

@@ -93,4 +93,11 @@ public class StoreController(StoreService service) : ControllerBase
         var result = await service.GetDashboardAsync(id, period);
         return result is null ? NotFound() : Ok(result);
     }
+
+    [HttpPatch("{id:guid}/kyc-status")]
+    public async Task<IActionResult> PatchKycStatus(Guid id, PatchKycStatusRequest request, CancellationToken ct)
+    {
+        var result = await service.VerifyKycAsync(id, new VerifyKycRequest(request.KycStatus, null), ct);
+        return result is null ? NotFound() : Ok(result);
+    }
 }

Distribution/Features/Store/StoreDTOs.cs

@@ -53,4 +53,6 @@ public record StoreVisitHistoryItem(Guid VisitId, DateTime VisitDate, Guid RepUs
 
 public record SchemeEligibilityResponse(bool Eligible, string? Reason);
 
+public record PatchKycStatusRequest(KycStatus KycStatus);
+
 public record StoreDashboardResponse(Guid StoreId, string Period, int OrderCount, decimal TotalOrderValue, DateTime? LastOrderDate);