Facility booking-mode redesign, multi-plan subscriptions, and Classes

Implements the facility-classes-booking-dashboard plan (backend):

- Facility.BookingMode (single Scheduled/AdHoc choice) replaced with
  independent SupportsClasses/SupportsBooking flags, so one facility
  can run a class and accept walk-in bookings; a running class now
  blocks walk-in booking for its window on both create and reschedule.
- CustomerPlan.GrantsGymAccess + CustomerPlanClass join table let a
  customer hold one gym-access plan plus any number of class-only
  plans. Replaced the old single-subscription resolution
  (GetActiveSubscriptionByCustomerId/HasAnyActiveSubscriptionAsync)
  with gym-access-aware and class-aware resolvers across booking
  creation/cancellation, plan assignment, and customer self-service.
  Fixed ChangeMembershipPlan/renewal plan-changes, which resolved "the
  subscription to replace" by most-recent-created and would have
  deactivated a member's class subscription instead of their gym one.
- New FacilityClass model: recurring class definitions (Daily/Weekly/
  Monthly/Custom) with lazy occurrence generation (8-week horizon,
  race-safe via a unique index) and proper unlimited-capacity handling.
  "Mark not held" replaces the old bare-cancel: cascades to cancel and
  refund every confirmed booking on the occurrence through the same
  core CancelBooking uses, and frees the slot for walk-in booking.
  Scheduling conflicts (a walk-in booking now overlapping a class) are
  surfaced for staff to resolve via the existing Reschedule flow.
- Renamed the pre-existing "AdHoc" booking-mode terminology to
  "WalkIn" throughout (routes, methods, DTOs, the stored BookingMode
  value) for a clearer, simpler name.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

CentralDbContext.cs

@@ -152,6 +152,7 @@ namespace Fitness_core_BE
                 new NavItem { Key = "memberships", Label = "Memberships", Href = "/dashboard/memberships", Icon = "CreditCard", SortOrder = 3, IsOwnerOnly = false },
                 new NavItem { Key = "bookings", Label = "Bookings", Href = "/dashboard/bookings", Icon = "CalendarClock", SortOrder = 4, IsOwnerOnly = false },
                 new NavItem { Key = "customer-payments", Label = "Customer Payments", ShortLabel = "Payments", Href = "/dashboard/customer-payments", Icon = "Receipt", SortOrder = 5, IsOwnerOnly = false },
+                new NavItem { Key = "inventory", Label = "Inventory", Href = "/dashboard/inventory", Icon = "Package", SortOrder = 6, IsOwnerOnly = false },
                 new NavItem { Key = "workout-plans", Label = "Workout Plans", Href = "/dashboard/workout-plans", Icon = "Activity", SortOrder = 7, IsOwnerOnly = false },
                 new NavItem { Key = "meal-plans", Label = "Meal Plans", Href = "/dashboard/meal-plans", Icon = "Utensils", SortOrder = 8, IsOwnerOnly = false },
                 new NavItem { Key = "staff", Label = "Staff", Href = "/dashboard/staff", Icon = "UsersRound", SortOrder = 9, IsOwnerOnly = false },

Controllers/BookingController.cs

@@ -34,9 +34,9 @@ namespace Fitness_core_BE.Controllers
 
         [CustomMiddleware]
         [TenantResolution]
-        [HttpPost("api/app/bookings/adhoc")]
-        public async Task<ActionResult<ApiResponse<object>>> CreateMemberAdhocBooking([FromBody] CreateAdhocBookingRequest request)
-            => Response(await _bookingService.CreateMemberAdhocBooking(new
+        [HttpPost("api/app/bookings/walkin")]
+        public async Task<ActionResult<ApiResponse<object>>> CreateMemberWalkInBooking([FromBody] CreateWalkInBookingRequest request)
+            => Response(await _bookingService.CreateMemberWalkInBooking(new
             {
                 facilityId = request.FacilityId,
                 startTime = request.StartTime.ToString("o"),
@@ -70,9 +70,9 @@ namespace Fitness_core_BE.Controllers
             }, HttpContext));
 
         [AllowAnonymous]
-        [HttpPost("api/public/bookings/guest/adhoc")]
-        public async Task<ActionResult<ApiResponse<object>>> CreateGuestAdhocBooking([FromBody] CreateGuestAdhocBookingRequest request)
-            => Response(await _bookingService.CreateGuestAdhocBooking(new
+        [HttpPost("api/public/bookings/guest/walkin")]
+        public async Task<ActionResult<ApiResponse<object>>> CreateGuestWalkInBooking([FromBody] CreateGuestWalkInBookingRequest request)
+            => Response(await _bookingService.CreateGuestWalkInBooking(new
             {
                 facilityId = request.FacilityId,
                 startTime = request.StartTime.ToString("o"),

Controllers/ClientController.cs

@@ -639,6 +639,8 @@ namespace Fitness_core_BE.Controllers
             if (request.RolloverGraceDays.HasValue) payload["rolloverGraceDays"] = request.RolloverGraceDays.Value;
             if (request.BillingTiming != null) payload["billingTiming"] = request.BillingTiming;
             if (request.PlaceIds != null) payload["placeIds"] = request.PlaceIds;
+            if (request.FacilityClassId.HasValue) payload["facilityClassId"] = request.FacilityClassId.Value;
+            if (request.GrantsGymAccess.HasValue) payload["grantsGymAccess"] = request.GrantsGymAccess.Value;
 
             return Response(await _customerPlanService.CreateCustomerPlan(payload, HttpContext));
         }

Controllers/FacilityClassController.cs

@@ -0,0 +1,97 @@
+using Fitness_core_BE.DTOs.Facility;
+using Fitness_core_BE.Helpers;
+using Fitness_core_BE.Interfaces.Services;
+using Fitness_core_BE.Models.IOs;
+using Microsoft.AspNetCore.Mvc;
+using static Fitness_core_BE.Helpers.JwtMiddleware;
+using static Fitness_core_BE.Helpers.ApiResponseHelper;
+
+namespace Fitness_core_BE.Controllers
+{
+    // Recurring class definitions + their occurrences -- the Classes tab's entry point. Gated on
+    // "memberships" (same as FacilityController's own mutations) since class setup is staff/
+    // membership configuration, not a booking-time read. The existing GET api/client/facilities/
+    // sessions* ("bookings"-gated) stays separate for the Booking Dashboard calendar.
+    [ApiController]
+    [Route("api/client/facility-classes")]
+    public class FacilityClassController(IClassService classService, IFacilityService facilityService) : ControllerBase
+    {
+        private readonly IClassService _classService = classService;
+        private readonly IFacilityService _facilityService = facilityService;
+
+        [CustomMiddleware]
+        [TenantResolution]
+        [RequiresPermission("memberships")]
+        [HttpGet("")]
+        public async Task<ActionResult<ApiResponse<object>>> GetFacilityClasses([FromQuery] bool includeInactive = false)
+            => Response(await _classService.GetFacilityClasses(new { includeInactive }, HttpContext));
+
+        [CustomMiddleware]
+        [TenantResolution]
+        [RequiresPermission("memberships")]
+        [HttpPost("")]
+        public async Task<ActionResult<ApiResponse<object>>> CreateFacilityClass([FromBody] CreateFacilityClassRequest request)
+            => Response(await _classService.CreateFacilityClass(new
+            {
+                facilityId = request.FacilityId,
+                name = request.Name,
+                description = request.Description,
+                recurrenceType = request.RecurrenceType,
+                startTimeOfDay = request.StartTimeOfDay,
+                durationMinutes = request.DurationMinutes,
+                weekDaysMask = request.WeekDaysMask,
+                monthDays = request.MonthDays,
+                seriesStartDate = request.SeriesStartDate?.ToString("o"),
+                seriesEndDate = request.SeriesEndDate?.ToString("o"),
+                capacity = request.Capacity,
+                isUnlimitedCapacity = request.IsUnlimitedCapacity,
+                customOccurrences = request.CustomOccurrences?.Select(o => new { startTime = o.StartTime.ToString("o"), durationMinutes = o.DurationMinutes })
+            }, HttpContext));
+
+        [CustomMiddleware]
+        [TenantResolution]
+        [RequiresPermission("memberships")]
+        [HttpPut("{id:guid}")]
+        public async Task<ActionResult<ApiResponse<object>>> UpdateFacilityClass(Guid id, [FromBody] UpdateFacilityClassRequest request)
+        {
+            var payload = new Dictionary<string, object?> { ["facilityClassId"] = id };
+            if (request.Name != null) payload["name"] = request.Name;
+            if (request.Description != null) payload["description"] = request.Description;
+            if (request.RecurrenceType != null) payload["recurrenceType"] = request.RecurrenceType;
+            if (request.StartTimeOfDay != null) payload["startTimeOfDay"] = request.StartTimeOfDay;
+            if (request.DurationMinutes.HasValue) payload["durationMinutes"] = request.DurationMinutes.Value;
+            if (request.WeekDaysMask.HasValue) payload["weekDaysMask"] = request.WeekDaysMask.Value;
+            if (request.MonthDays != null) payload["monthDays"] = request.MonthDays;
+            if (request.SeriesStartDate.HasValue) payload["seriesStartDate"] = request.SeriesStartDate.Value.ToString("o");
+            if (request.SeriesEndDate.HasValue) payload["seriesEndDate"] = request.SeriesEndDate.Value.ToString("o");
+            if (request.Capacity.HasValue) payload["capacity"] = request.Capacity.Value;
+            if (request.IsUnlimitedCapacity.HasValue) payload["isUnlimitedCapacity"] = request.IsUnlimitedCapacity.Value;
+            if (request.IsActive.HasValue) payload["isActive"] = request.IsActive.Value;
+            if (request.AddCustomOccurrences != null)
+                payload["addCustomOccurrences"] = request.AddCustomOccurrences.Select(o => new { startTime = o.StartTime.ToString("o"), durationMinutes = o.DurationMinutes });
+
+            return Response(await _classService.UpdateFacilityClass(payload, HttpContext));
+        }
+
+        [CustomMiddleware]
+        [TenantResolution]
+        [RequiresPermission("memberships")]
+        [HttpGet("{id:guid}/occurrences")]
+        public async Task<ActionResult<ApiResponse<object>>> GetOccurrences(Guid id, [FromQuery] bool includeCancelled = false)
+            => Response(await _classService.GetOccurrences(new { facilityClassId = id, includeCancelled }, HttpContext));
+
+        [CustomMiddleware]
+        [TenantResolution]
+        [RequiresPermission("memberships")]
+        [HttpPost("{id:guid}/occurrences/{occurrenceId:guid}/not-held")]
+        public async Task<ActionResult<ApiResponse<object>>> MarkOccurrenceNotHeld(Guid id, Guid occurrenceId, [FromBody] MarkNotHeldRequest? request)
+            => Response(await _facilityService.CancelFacilitySession(new { facilitySessionId = occurrenceId, reason = request?.Reason }, HttpContext));
+
+        [CustomMiddleware]
+        [TenantResolution]
+        [RequiresPermission("memberships")]
+        [HttpGet("scheduling-conflicts")]
+        public async Task<ActionResult<ApiResponse<object>>> GetSchedulingConflicts()
+            => Response(await _classService.GetSchedulingConflicts(new { }, HttpContext));
+    }
+}

Controllers/FacilityController.cs

@@ -33,7 +33,8 @@ namespace Fitness_core_BE.Controllers
             => Response(await _facilityService.CreateFacility(new
             {
                 name = request.Name,
-                bookingMode = request.BookingMode,
+                supportsClasses = request.SupportsClasses,
+                supportsBooking = request.SupportsBooking,
                 description = request.Description,
                 defaultCapacity = request.DefaultCapacity,
                 numberOfUnits = request.NumberOfUnits,
@@ -48,7 +49,8 @@ namespace Fitness_core_BE.Controllers
         {
             var payload = new Dictionary<string, object> { ["facilityId"] = id };
             if (request.Name != null) payload["name"] = request.Name;
-            if (request.BookingMode != null) payload["bookingMode"] = request.BookingMode;
+            if (request.SupportsClasses.HasValue) payload["supportsClasses"] = request.SupportsClasses.Value;
+            if (request.SupportsBooking.HasValue) payload["supportsBooking"] = request.SupportsBooking.Value;
             if (request.Description != null) payload["description"] = request.Description;
             if (request.DefaultCapacity.HasValue) payload["defaultCapacity"] = request.DefaultCapacity.Value;
             if (request.NumberOfUnits.HasValue) payload["numberOfUnits"] = request.NumberOfUnits.Value;
@@ -90,20 +92,21 @@ namespace Fitness_core_BE.Controllers
         [RequiresPermission("bookings")]
         [HttpGet("sessions")]
         public async Task<ActionResult<ApiResponse<object>>> GetSessions(
-            [FromQuery] Guid? facilityId, [FromQuery] DateTime? fromDate, [FromQuery] DateTime? toDate)
+            [FromQuery] Guid? facilityId, [FromQuery] DateTime? fromDate, [FromQuery] DateTime? toDate, [FromQuery] bool includeCancelled = false)
             => Response(await _facilityService.GetSessions(new
             {
                 facilityId,
                 fromDate = fromDate?.ToString("o"),
-                toDate = toDate?.ToString("o")
+                toDate = toDate?.ToString("o"),
+                includeCancelled
             }, HttpContext));
 
         [CustomMiddleware]
         [TenantResolution]
         [RequiresPermission("bookings")]
         [HttpDelete("sessions/{id:guid}")]
-        public async Task<ActionResult<ApiResponse<object>>> CancelFacilitySession(Guid id)
-            => Response(await _facilityService.CancelFacilitySession(new { facilitySessionId = id }, HttpContext));
+        public async Task<ActionResult<ApiResponse<object>>> CancelFacilitySession(Guid id, [FromBody] MarkNotHeldRequest? request)
+            => Response(await _facilityService.CancelFacilitySession(new { facilitySessionId = id, reason = request?.Reason }, HttpContext));
 
         [CustomMiddleware]
         [TenantResolution]

Controllers/InventoryController.cs

@@ -0,0 +1,181 @@
+using Fitness_core_BE.DTOs.Inventory;
+using Fitness_core_BE.Helpers;
+using Fitness_core_BE.Interfaces.Services;
+using Fitness_core_BE.Models.IOs;
+using Microsoft.AspNetCore.Mvc;
+using static Fitness_core_BE.Helpers.JwtMiddleware;
+using static Fitness_core_BE.Helpers.ApiResponseHelper;
+
+namespace Fitness_core_BE.Controllers
+{
+    // Simple inventory: Products, Suppliers, GRN (stock in), Sales (stock out) and Returns
+    // (stock write-offs). All gated on the "inventory" nav permission.
+    [ApiController]
+    [Route("api/client/inventory")]
+    public class InventoryController(IInventoryService inventoryService) : ControllerBase
+    {
+        private readonly IInventoryService _inventoryService = inventoryService;
+
+        [CustomMiddleware]
+        [TenantResolution]
+        [RequiresPermission("inventory")]
+        [HttpGet("products")]
+        public async Task<ActionResult<ApiResponse<object>>> GetProducts([FromQuery] bool includeInactive = false)
+            => Response(await _inventoryService.GetProducts(new { includeInactive }, HttpContext));
+
+        [CustomMiddleware]
+        [TenantResolution]
+        [RequiresPermission("inventory")]
+        [HttpGet("products/{id:guid}")]
+        public async Task<ActionResult<ApiResponse<object>>> GetProductById(Guid id)
+            => Response(await _inventoryService.GetProductById(new { productId = id }, HttpContext));
+
+        [CustomMiddleware]
+        [TenantResolution]
+        [RequiresPermission("inventory")]
+        [HttpPost("products")]
+        public async Task<ActionResult<ApiResponse<object>>> CreateProduct([FromBody] CreateProductRequest request)
+            => Response(await _inventoryService.CreateProduct(new
+            {
+                name = request.Name,
+                unitOfMeasure = request.UnitOfMeasure,
+                sellingPrice = request.SellingPrice
+            }, HttpContext));
+
+        [CustomMiddleware]
+        [TenantResolution]
+        [RequiresPermission("inventory")]
+        [HttpPut("products/{id:guid}")]
+        public async Task<ActionResult<ApiResponse<object>>> UpdateProduct(Guid id, [FromBody] UpdateProductRequest request)
+        {
+            var payload = new Dictionary<string, object?> { ["productId"] = id };
+            if (request.Name != null) payload["name"] = request.Name;
+            if (request.UnitOfMeasure != null) payload["unitOfMeasure"] = request.UnitOfMeasure;
+            if (request.SellingPrice.HasValue) payload["sellingPrice"] = request.SellingPrice.Value;
+            if (request.IsActive.HasValue) payload["isActive"] = request.IsActive.Value;
+
+            return Response(await _inventoryService.UpdateProduct(payload, HttpContext));
+        }
+
+        [CustomMiddleware]
+        [TenantResolution]
+        [RequiresPermission("inventory")]
+        [HttpPost("products/{id:guid}/image")]
+        [RequestSizeLimit(6_000_000)]
+        [Consumes("multipart/form-data")]
+        public async Task<ActionResult<ApiResponse<object>>> UploadProductImage(Guid id, [FromForm] IFormFile image)
+            => Response(await _inventoryService.UploadProductImage(id, image, HttpContext));
+
+        [CustomMiddleware]
+        [TenantResolution]
+        [RequiresPermission("inventory")]
+        [HttpGet("suppliers")]
+        public async Task<ActionResult<ApiResponse<object>>> GetSuppliers([FromQuery] bool includeInactive = false)
+            => Response(await _inventoryService.GetSuppliers(new { includeInactive }, HttpContext));
+
+        [CustomMiddleware]
+        [TenantResolution]
+        [RequiresPermission("inventory")]
+        [HttpPost("suppliers")]
+        public async Task<ActionResult<ApiResponse<object>>> CreateSupplier([FromBody] CreateSupplierRequest request)
+            => Response(await _inventoryService.CreateSupplier(new
+            {
+                name = request.Name,
+                phone = request.Phone,
+                email = request.Email,
+                address = request.Address
+            }, HttpContext));
+
+        [CustomMiddleware]
+        [TenantResolution]
+        [RequiresPermission("inventory")]
+        [HttpGet("grn")]
+        public async Task<ActionResult<ApiResponse<object>>> GetGrns()
+            => Response(await _inventoryService.GetGrns(new { }, HttpContext));
+
+        [CustomMiddleware]
+        [TenantResolution]
+        [RequiresPermission("inventory")]
+        [HttpGet("grn/{id:guid}")]
+        public async Task<ActionResult<ApiResponse<object>>> GetGrnById(Guid id)
+            => Response(await _inventoryService.GetGrnById(new { grnId = id }, HttpContext));
+
+        [CustomMiddleware]
+        [TenantResolution]
+        [RequiresPermission("inventory")]
+        [HttpPost("grn")]
+        public async Task<ActionResult<ApiResponse<object>>> CreateGrn([FromBody] CreateGrnRequest request)
+            => Response(await _inventoryService.CreateGrn(new
+            {
+                supplierId = request.SupplierId,
+                receivedAt = request.ReceivedAt?.ToString("o"),
+                notes = request.Notes,
+                items = request.Items.Select(i => new { productId = i.ProductId, quantity = i.Quantity, unitCost = i.UnitCost })
+            }, HttpContext));
+
+        [CustomMiddleware]
+        [TenantResolution]
+        [RequiresPermission("inventory")]
+        [HttpGet("sales")]
+        public async Task<ActionResult<ApiResponse<object>>> GetSales()
+            => Response(await _inventoryService.GetSales(new { }, HttpContext));
+
+        [CustomMiddleware]
+        [TenantResolution]
+        [RequiresPermission("inventory")]
+        [HttpGet("sales/{id:guid}")]
+        public async Task<ActionResult<ApiResponse<object>>> GetSaleById(Guid id)
+            => Response(await _inventoryService.GetSaleById(new { saleId = id }, HttpContext));
+
+        [CustomMiddleware]
+        [TenantResolution]
+        [RequiresPermission("inventory")]
+        [HttpPost("sales")]
+        public async Task<ActionResult<ApiResponse<object>>> CreateSale([FromBody] CreateSaleRequest request)
+            => Response(await _inventoryService.CreateSale(new
+            {
+                soldAt = request.SoldAt?.ToString("o"),
+                paymentMethod = request.PaymentMethod,
+                customerId = request.CustomerId,
+                customerName = request.CustomerName,
+                items = request.Items.Select(i => new { productId = i.ProductId, quantity = i.Quantity, unitPrice = i.UnitPrice })
+            }, HttpContext));
+
+        [CustomMiddleware]
+        [TenantResolution]
+        [RequiresPermission("inventory")]
+        [HttpGet("returns")]
+        public async Task<ActionResult<ApiResponse<object>>> GetStockReturns()
+            => Response(await _inventoryService.GetStockReturns(new { }, HttpContext));
+
+        [CustomMiddleware]
+        [TenantResolution]
+        [RequiresPermission("inventory")]
+        [HttpGet("returns/{id:guid}")]
+        public async Task<ActionResult<ApiResponse<object>>> GetStockReturnById(Guid id)
+            => Response(await _inventoryService.GetStockReturnById(new { stockReturnId = id }, HttpContext));
+
+        [CustomMiddleware]
+        [TenantResolution]
+        [RequiresPermission("inventory")]
+        [HttpPost("returns")]
+        public async Task<ActionResult<ApiResponse<object>>> CreateStockReturn([FromBody] CreateStockReturnRequest request)
+            => Response(await _inventoryService.CreateStockReturn(new
+            {
+                productId = request.ProductId,
+                quantity = request.Quantity,
+                category = request.Category,
+                saleId = request.SaleId,
+                grnId = request.GrnId,
+                notes = request.Notes,
+                returnedAt = request.ReturnedAt?.ToString("o")
+            }, HttpContext));
+
+        [CustomMiddleware]
+        [TenantResolution]
+        [RequiresPermission("inventory")]
+        [HttpGet("stock-movements")]
+        public async Task<ActionResult<ApiResponse<object>>> GetStockMovements()
+            => Response(await _inventoryService.GetStockMovements(new { }, HttpContext));
+    }
+}

DTOs/Booking/BookingDto.cs

@@ -4,20 +4,20 @@ namespace Fitness_core_BE.DTOs.Booking
     {
         public Guid BookingId { get; set; }
 
-        /// <summary>Null for an AdHoc booking (no pre-created session).</summary>
+        /// <summary>Null for a WalkIn booking (no pre-created session).</summary>
         public Guid? FacilitySessionId { get; set; }
         public Guid FacilityId { get; set; }
         public string? FacilityName { get; set; }
 
-        /// <summary>"Scheduled" | "AdHoc" -- read off the facility, tells the FE which action set
-        /// applies (e.g. AdHoc bookings can be rescheduled to any free time; Scheduled ones only
-        /// to another session).</summary>
+        /// <summary>"Scheduled" | "WalkIn" -- tells the FE which action set applies (e.g. WalkIn
+        /// bookings can be rescheduled to any free time; Scheduled ones only to another
+        /// session).</summary>
         public string BookingMode { get; set; } = string.Empty;
 
         public DateTime StartTime { get; set; }
         public DateTime EndTime { get; set; }
 
-        /// <summary>Informational headcount, AdHoc only.</summary>
+        /// <summary>Informational headcount, WalkIn only.</summary>
         public int? PartySize { get; set; }
 
         public bool IsGuest { get; set; }

DTOs/Booking/BookingRequests.cs

@@ -25,7 +25,7 @@ namespace Fitness_core_BE.DTOs.Booking
         public Guid? CustomerId { get; set; }
     }
 
-    public class CreateAdhocBookingRequest
+    public class CreateWalkInBookingRequest
     {
         [Required]
         public Guid FacilityId { get; set; }
@@ -39,7 +39,7 @@ namespace Fitness_core_BE.DTOs.Booking
         public int? PartySize { get; set; }
     }
 
-    public class CreateGuestAdhocBookingRequest
+    public class CreateGuestWalkInBookingRequest
     {
         [Required]
         public Guid FacilityId { get; set; }
@@ -98,7 +98,7 @@ namespace Fitness_core_BE.DTOs.Booking
         public string OtpCode { get; set; } = string.Empty;
 
         /// <summary>Picked from the club's managed RFID tag pool (GET api/client/rfid-tags?
-        /// status=Available) -- never free-typed. Required in practice for an AdHoc booking's
+        /// status=Available) -- never free-typed. Required in practice for a WalkIn booking's
         /// check-in; optional for Scheduled bookings that don't hand out a physical tag.</summary>
         public Guid? RfidTagId { get; set; }
     }
@@ -115,14 +115,14 @@ namespace Fitness_core_BE.DTOs.Booking
         public string? GuestPhone { get; set; }
     }
 
-    /// <summary>Exactly one shape applies, matching the booking's current BookingMode: AdHoc
+    /// <summary>Exactly one shape applies, matching the booking's current BookingMode: WalkIn
     /// bookings move within the SAME facility to a new StartTime/DurationMinutes; Scheduled
     /// bookings move to a different FacilitySession (also on the same facility). Only allowed
     /// while the booking is still Confirmed, and only onto a slot with room -- re-runs the same
     /// availability check as creation, excluding the booking's own current slot.</summary>
     public class RescheduleBookingRequest
     {
-        // AdHoc reschedule.
+        // WalkIn reschedule.
         public DateTime? StartTime { get; set; }
         [Range(1, int.MaxValue, ErrorMessage = "DurationMinutes must be at least 1")]
         public int? DurationMinutes { get; set; }

DTOs/CustomerPlan/CreateCustomerPlanRequest.cs

@@ -58,5 +58,14 @@ namespace Fitness_core_BE.DTOs.CustomerPlan
         /// <summary>Places this plan grants access to. Null/omitted or empty = unrestricted
         /// (reaches every active access device, today's behavior).</summary>
         public List<Guid>? PlaceIds { get; set; }
+
+        /// <summary>Set only by the Classes tab's "Manage Plan" action -- links this new plan to
+        /// one class via CustomerPlanClass. Omitted for an ordinary gym plan.</summary>
+        public Guid? FacilityClassId { get; set; }
+
+        /// <summary>Only meaningful when FacilityClassId is set -- whether this class plan also
+        /// grants general gym-floor access ("class + gym" as one product) instead of class-only.
+        /// Defaults to false (class-only) when omitted.</summary>
+        public bool? GrantsGymAccess { get; set; }
     }
 }

DTOs/Facility/FacilityClassDtos.cs

@@ -0,0 +1,36 @@
+namespace Fitness_core_BE.DTOs.Facility
+{
+    public class FacilityClassDto
+    {
+        public Guid FacilityClassId { get; set; }
+        public Guid FacilityId { get; set; }
+        public string? FacilityName { get; set; }
+        public string Name { get; set; } = string.Empty;
+        public string? Description { get; set; }
+        /// <summary>"Daily" | "Weekly" | "Monthly" | "Custom".</summary>
+        public string RecurrenceType { get; set; } = string.Empty;
+        /// <summary>"HH:mm" local time -- null for Custom.</summary>
+        public string? StartTimeOfDay { get; set; }
+        public int DurationMinutes { get; set; }
+        public int WeekDaysMask { get; set; }
+        public string? MonthDays { get; set; }
+        public DateTime SeriesStartDate { get; set; }
+        public DateTime? SeriesEndDate { get; set; }
+        public int? Capacity { get; set; }
+        public bool IsUnlimitedCapacity { get; set; }
+        public bool IsActive { get; set; }
+        public DateTime CreatedAt { get; set; }
+    }
+
+    /// <summary>A confirmed ad-hoc booking whose window overlaps an active class occurrence on
+    /// the same facility -- surfaced so staff can resolve it via the existing Reschedule flow.</summary>
+    public class SchedulingConflictDto
+    {
+        public Guid BookingId { get; set; }
+        public Guid FacilityId { get; set; }
+        public string? FacilityName { get; set; }
+        public string? GuestName { get; set; }
+        public DateTime StartTime { get; set; }
+        public DateTime EndTime { get; set; }
+    }
+}

DTOs/Facility/FacilityClassRequests.cs

@@ -0,0 +1,74 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace Fitness_core_BE.DTOs.Facility
+{
+    public class CustomOccurrenceRequest
+    {
+        [Required]
+        public DateTime StartTime { get; set; }
+
+        [Required, Range(1, int.MaxValue, ErrorMessage = "DurationMinutes must be at least 1")]
+        public int DurationMinutes { get; set; }
+    }
+
+    public class CreateFacilityClassRequest
+    {
+        [Required]
+        public Guid FacilityId { get; set; }
+
+        [Required]
+        public string Name { get; set; } = string.Empty;
+
+        public string? Description { get; set; }
+
+        /// <summary>"Daily" | "Weekly" | "Monthly" | "Custom".</summary>
+        [Required]
+        public string RecurrenceType { get; set; } = "Weekly";
+
+        /// <summary>"HH:mm" local time -- required unless RecurrenceType == "Custom".</summary>
+        public string? StartTimeOfDay { get; set; }
+
+        [Range(1, int.MaxValue, ErrorMessage = "DurationMinutes must be at least 1")]
+        public int DurationMinutes { get; set; } = 60;
+
+        /// <summary>Weekly only. Bit flags, Sunday = 1 through Saturday = 64.</summary>
+        public int WeekDaysMask { get; set; }
+
+        /// <summary>Monthly only. Comma-separated day-of-month list, e.g. "1,15".</summary>
+        public string? MonthDays { get; set; }
+
+        public DateTime? SeriesStartDate { get; set; }
+        public DateTime? SeriesEndDate { get; set; }
+
+        public int? Capacity { get; set; }
+        public bool IsUnlimitedCapacity { get; set; }
+
+        /// <summary>RecurrenceType == "Custom" only -- explicit occurrence windows.</summary>
+        public List<CustomOccurrenceRequest>? CustomOccurrences { get; set; }
+    }
+
+    public class UpdateFacilityClassRequest
+    {
+        public string? Name { get; set; }
+        public string? Description { get; set; }
+        public string? RecurrenceType { get; set; }
+        public string? StartTimeOfDay { get; set; }
+        public int? DurationMinutes { get; set; }
+        public int? WeekDaysMask { get; set; }
+        public string? MonthDays { get; set; }
+        public DateTime? SeriesStartDate { get; set; }
+        public DateTime? SeriesEndDate { get; set; }
+        public int? Capacity { get; set; }
+        public bool? IsUnlimitedCapacity { get; set; }
+        public bool? IsActive { get; set; }
+
+        /// <summary>RecurrenceType == "Custom" only -- adds more explicit occurrences without
+        /// touching existing ones (Custom has no rule to regenerate from).</summary>
+        public List<CustomOccurrenceRequest>? AddCustomOccurrences { get; set; }
+    }
+
+    public class MarkNotHeldRequest
+    {
+        public string? Reason { get; set; }
+    }
+}

DTOs/Facility/FacilityDtos.cs

@@ -5,8 +5,8 @@ namespace Fitness_core_BE.DTOs.Facility
         public Guid FacilityId { get; set; }
         public string Name { get; set; } = string.Empty;
 
-        /// <summary>"Scheduled" | "AdHoc".</summary>
-        public string BookingMode { get; set; } = "Scheduled";
+        public bool SupportsClasses { get; set; }
+        public bool SupportsBooking { get; set; }
         public string? Description { get; set; }
         public int DefaultCapacity { get; set; }
         public int NumberOfUnits { get; set; }
@@ -27,20 +27,35 @@ namespace Fitness_core_BE.DTOs.Facility
         public DateTime StartTime { get; set; }
         public DateTime EndTime { get; set; }
         public int Capacity { get; set; }
+        /// <summary>When true, Capacity above is meaningless -- this occurrence has no cap.</summary>
+        public bool IsUnlimitedCapacity { get; set; }
         public int BookedCount { get; set; }
         public bool IsCancelled { get; set; }
+        /// <summary>Null for a manually-created session; set for a class occurrence.</summary>
+        public Guid? FacilityClassId { get; set; }
+        public string? FacilityClassName { get; set; }
+        public string? NotHeldReason { get; set; }
+        public DateTime? NotHeldAt { get; set; }
     }
 
     /// <summary>GET api/client/facilities/availability -- how much room is left for a requested
-    /// window, uniformly across both booking modes (TotalUnits/UnitsFree mean NumberOfUnits/
-    /// overlap-count for AdHoc, DefaultCapacity/free-session-spots for Scheduled).</summary>
+    /// window. A facility can support both booking and classes at once, so the two number pairs
+    /// are independently nullable: null means "this facility doesn't offer that mode," not zero.
+    /// BookingUnitsFree is forced to 0 when an active (non-cancelled) class occupies the window --
+    /// a running class occupies the whole facility, not just a seat.</summary>
     public class FacilityAvailabilityDto
     {
         public Guid FacilityId { get; set; }
         public string FacilityName { get; set; } = string.Empty;
-        public string BookingMode { get; set; } = string.Empty;
-        public int TotalUnits { get; set; }
-        public int UnitsFree { get; set; }
+        public bool SupportsClasses { get; set; }
+        public bool SupportsBooking { get; set; }
+        public int? BookingTotalUnits { get; set; }
+        public int? BookingUnitsFree { get; set; }
+        public int? ClassTotalCapacity { get; set; }
+        public int? ClassUnitsFree { get; set; }
+        /// <summary>True when an overlapping class occurrence has no headcount cap -- when set,
+        /// ClassTotalCapacity/ClassUnitsFree stay null (unbounded, not zero).</summary>
+        public bool ClassIsUnlimitedCapacity { get; set; }
         public decimal PricePerHour { get; set; }
     }
 }

DTOs/Facility/FacilityRequests.cs

@@ -7,17 +7,17 @@ namespace Fitness_core_BE.DTOs.Facility
         [Required]
         public string Name { get; set; } = string.Empty;
 
-        /// <summary>"Scheduled" | "AdHoc".</summary>
-        [Required]
-        public string BookingMode { get; set; } = "Scheduled";
+        /// <summary>At least one of SupportsClasses/SupportsBooking must be true.</summary>
+        public bool SupportsClasses { get; set; } = true;
+        public bool SupportsBooking { get; set; } = false;
 
         public string? Description { get; set; }
 
-        /// <summary>Required (meaningfully) when BookingMode == "Scheduled".</summary>
+        /// <summary>Required (meaningfully) when SupportsClasses.</summary>
         [Range(1, int.MaxValue, ErrorMessage = "DefaultCapacity must be at least 1")]
         public int DefaultCapacity { get; set; } = 1;
 
-        /// <summary>Required (meaningfully) when BookingMode == "AdHoc" -- e.g. 3 for "3 courts".</summary>
+        /// <summary>Required (meaningfully) when SupportsBooking -- e.g. 3 for "3 courts".</summary>
         [Range(1, int.MaxValue, ErrorMessage = "NumberOfUnits must be at least 1")]
         public int NumberOfUnits { get; set; } = 1;
 
@@ -30,7 +30,8 @@ namespace Fitness_core_BE.DTOs.Facility
         [Required]
         public Guid FacilityId { get; set; }
         public string? Name { get; set; }
-        public string? BookingMode { get; set; }
+        public bool? SupportsClasses { get; set; }
+        public bool? SupportsBooking { get; set; }
         public string? Description { get; set; }
         public int? DefaultCapacity { get; set; }
         public int? NumberOfUnits { get; set; }

DTOs/Inventory/InventoryDtos.cs

@@ -0,0 +1,127 @@
+namespace Fitness_core_BE.DTOs.Inventory
+{
+    public class ProductDto
+    {
+        public Guid ProductId { get; set; }
+        public string Name { get; set; } = string.Empty;
+        public string? Sku { get; set; }
+        /// <summary>Base64 data URL, computed on read from ImageId -- null when no image is set.</summary>
+        public string? ImageUrl { get; set; }
+        public string UnitOfMeasure { get; set; } = string.Empty;
+        public decimal CostPrice { get; set; }
+        public decimal SellingPrice { get; set; }
+        public decimal QuantityOnHand { get; set; }
+        public bool IsActive { get; set; }
+        public DateTime CreatedAt { get; set; }
+    }
+
+    /// <summary>One row in a Product's detail-page stock-movement history.</summary>
+    public class ProductMovementDto
+    {
+        /// <summary>"GRN" | "Sale" | "Return".</summary>
+        public string Type { get; set; } = string.Empty;
+        /// <summary>The GRN/Sale number, or the return's Category.</summary>
+        public string Reference { get; set; } = string.Empty;
+        /// <summary>Signed: positive for a GRN (stock in), negative for a Sale or Return (stock out).</summary>
+        public decimal QuantityChange { get; set; }
+        public DateTime Date { get; set; }
+    }
+
+    public class ProductDetailDto : ProductDto
+    {
+        public List<ProductMovementDto> Movements { get; set; } = [];
+    }
+
+    public class SupplierDto
+    {
+        public Guid SupplierId { get; set; }
+        public string Name { get; set; } = string.Empty;
+        public string? Phone { get; set; }
+        public string? Email { get; set; }
+        public string? Address { get; set; }
+        public bool IsActive { get; set; }
+    }
+
+    public class GoodsReceivedNoteItemDto
+    {
+        public Guid ProductId { get; set; }
+        public string ProductName { get; set; } = string.Empty;
+        public decimal Quantity { get; set; }
+        public decimal UnitCost { get; set; }
+        public decimal LineTotal { get; set; }
+    }
+
+    public class GoodsReceivedNoteDto
+    {
+        public Guid GrnId { get; set; }
+        public string GrnNumber { get; set; } = string.Empty;
+        /// <summary>Null when this GRN was recorded without a supplier.</summary>
+        public Guid? SupplierId { get; set; }
+        public string? SupplierName { get; set; }
+        public DateTime ReceivedAt { get; set; }
+        public string? Notes { get; set; }
+        public decimal TotalAmount { get; set; }
+        public List<GoodsReceivedNoteItemDto> Items { get; set; } = [];
+    }
+
+    public class SaleItemDto
+    {
+        public Guid ProductId { get; set; }
+        public string ProductName { get; set; } = string.Empty;
+        public decimal Quantity { get; set; }
+        public decimal UnitPrice { get; set; }
+        public decimal LineTotal { get; set; }
+    }
+
+    public class SaleDto
+    {
+        public Guid SaleId { get; set; }
+        public string SaleNumber { get; set; } = string.Empty;
+        public DateTime SoldAt { get; set; }
+        public string PaymentMethod { get; set; } = string.Empty;
+        public Guid? CustomerId { get; set; }
+        public string? CustomerName { get; set; }
+        public decimal TotalAmount { get; set; }
+        public List<SaleItemDto> Items { get; set; } = [];
+    }
+
+    /// <summary>One row in the Stock Tracking tab's unified ledger -- every GRN line, sale line
+    /// and return across every product, flattened into one shape for a single filterable table.
+    /// Not persisted; built on read from GRNs/Sales/Returns.</summary>
+    public class StockMovementDto
+    {
+        /// <summary>"GRN" | "Sale" | "Return".</summary>
+        public string Type { get; set; } = string.Empty;
+        public Guid ProductId { get; set; }
+        public string ProductName { get; set; } = string.Empty;
+        /// <summary>The GRN/Sale number this line belongs to, or the return's Category label.</summary>
+        public string Reference { get; set; } = string.Empty;
+        /// <summary>Only set for Type == "Return" -- the write-off/return category.</summary>
+        public string? Category { get; set; }
+        /// <summary>Signed: positive for a GRN or a CustomerReturn (stock in), negative for a
+        /// Sale or any other return category (stock out).</summary>
+        public decimal QuantityChange { get; set; }
+        /// <summary>This line's monetary value -- a GRN/Sale line's LineTotal, or a return's Amount.</summary>
+        public decimal Amount { get; set; }
+        public DateTime Date { get; set; }
+    }
+
+    public class StockReturnDto
+    {
+        public Guid StockReturnId { get; set; }
+        public Guid ProductId { get; set; }
+        public string ProductName { get; set; } = string.Empty;
+        public decimal Quantity { get; set; }
+        public string Category { get; set; } = string.Empty;
+        /// <summary>Optional traceability link -- which sale this return came from, if any.</summary>
+        public Guid? SaleId { get; set; }
+        public string? SaleNumber { get; set; }
+        /// <summary>Optional traceability link -- which GRN this return relates to, if any.</summary>
+        public Guid? GrnId { get; set; }
+        public string? GrnNumber { get; set; }
+        public string? Notes { get; set; }
+        public DateTime ReturnedAt { get; set; }
+        /// <summary>Quantity * Product.CostPrice at the moment of the return -- auto-computed.</summary>
+        public decimal Amount { get; set; }
+    }
+}

DTOs/Inventory/InventoryRequests.cs

@@ -0,0 +1,107 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace Fitness_core_BE.DTOs.Inventory
+{
+    public class CreateProductRequest
+    {
+        [Required]
+        public string Name { get; set; } = string.Empty;
+        public string UnitOfMeasure { get; set; } = "pcs";
+
+        [Range(typeof(decimal), "0", "79228162514264337593543950335", ErrorMessage = "SellingPrice cannot be negative")]
+        public decimal SellingPrice { get; set; } = 0m;
+    }
+
+    /// <summary>Sku is system-generated at creation and never included here -- it can't be edited.</summary>
+    public class UpdateProductRequest
+    {
+        public string? Name { get; set; }
+        public string? UnitOfMeasure { get; set; }
+        public decimal? SellingPrice { get; set; }
+        public bool? IsActive { get; set; }
+    }
+
+    public class CreateSupplierRequest
+    {
+        [Required]
+        public string Name { get; set; } = string.Empty;
+        public string? Phone { get; set; }
+        public string? Email { get; set; }
+        public string? Address { get; set; }
+    }
+
+    public class GrnItemRequest
+    {
+        [Required]
+        public Guid ProductId { get; set; }
+
+        [Range(0.0001, double.MaxValue, ErrorMessage = "Quantity must be greater than 0")]
+        public decimal Quantity { get; set; }
+
+        [Range(typeof(decimal), "0", "79228162514264337593543950335", ErrorMessage = "UnitCost cannot be negative")]
+        public decimal UnitCost { get; set; }
+    }
+
+    public class CreateGrnRequest
+    {
+        /// <summary>Optional -- some GRNs don't have a supplier on file.</summary>
+        public Guid? SupplierId { get; set; }
+        public DateTime? ReceivedAt { get; set; }
+        public string? Notes { get; set; }
+
+        [Required, MinLength(1, ErrorMessage = "At least one item is required")]
+        public List<GrnItemRequest> Items { get; set; } = [];
+    }
+
+    public class SaleItemRequest
+    {
+        [Required]
+        public Guid ProductId { get; set; }
+
+        [Range(0.0001, double.MaxValue, ErrorMessage = "Quantity must be greater than 0")]
+        public decimal Quantity { get; set; }
+
+        [Range(typeof(decimal), "0", "79228162514264337593543950335", ErrorMessage = "UnitPrice cannot be negative")]
+        public decimal UnitPrice { get; set; }
+    }
+
+    public class CreateSaleRequest
+    {
+        public DateTime? SoldAt { get; set; }
+
+        /// <summary>"Cash" | "Bank".</summary>
+        [Required]
+        public string PaymentMethod { get; set; } = "Cash";
+
+        public Guid? CustomerId { get; set; }
+        public string? CustomerName { get; set; }
+
+        [Required, MinLength(1, ErrorMessage = "At least one item is required")]
+        public List<SaleItemRequest> Items { get; set; } = [];
+    }
+
+    public class CreateStockReturnRequest
+    {
+        [Required]
+        public Guid ProductId { get; set; }
+
+        [Range(0.0001, double.MaxValue, ErrorMessage = "Quantity must be greater than 0")]
+        public decimal Quantity { get; set; }
+
+        /// <summary>"Expired" | "Damaged" | "Lost" | "SupplierReturn" | "CustomerReturn" | "Other".
+        /// Only "CustomerReturn" adds back to stock; every other category removes from it.</summary>
+        [Required]
+        public string Category { get; set; } = "Other";
+
+        /// <summary>Optional traceability link -- e.g. a customer return that came from a
+        /// specific sale. Many returns (damaged shelf stock, etc.) don't have one.</summary>
+        public Guid? SaleId { get; set; }
+
+        /// <summary>Optional traceability link -- e.g. stock sent back to the supplier from a
+        /// specific GRN. Many returns don't have one.</summary>
+        public Guid? GrnId { get; set; }
+
+        public string? Notes { get; set; }
+        public DateTime? ReturnedAt { get; set; }
+    }
+}

Helpers/TimeZoneHelper.cs

@@ -0,0 +1,34 @@
+namespace Fitness_core_BE.Helpers
+{
+    // Every gym this runs for is Sri Lanka-based -- shared by SubscriptionRenewalJob (daily
+    // trigger wake-up) and the Classes feature (converting a class's local StartTimeOfDay to
+    // UTC per generated occurrence). Lifted out of SubscriptionRenewalJob rather than each
+    // caller re-deriving it.
+    public static class TimeZoneHelper
+    {
+        public static readonly TimeZoneInfo SriLanka = ResolveSriLankaTimeZone();
+
+        private static TimeZoneInfo ResolveSriLankaTimeZone()
+        {
+            try
+            {
+                return TimeZoneInfo.FindSystemTimeZoneById("Sri Lanka Standard Time"); // Windows ID
+            }
+            catch (TimeZoneNotFoundException)
+            {
+                try
+                {
+                    return TimeZoneInfo.FindSystemTimeZoneById("Asia/Colombo"); // IANA ID (Linux/macOS)
+                }
+                catch (TimeZoneNotFoundException)
+                {
+                    // Neither ID resolved (e.g. no tzdata on the host) -- Sri Lanka has kept a
+                    // fixed UTC+5:30 offset with no DST since 2006, so a custom fixed-offset
+                    // zone is a safe fallback rather than failing the whole caller.
+                    return TimeZoneInfo.CreateCustomTimeZone(
+                        "Sri Lanka (fixed +05:30)", TimeSpan.FromMinutes(330), "Sri Lanka Time", "Sri Lanka Time");
+                }
+            }
+        }
+    }
+}

Interfaces/IBookingRepository.cs

@@ -14,7 +14,7 @@ namespace Fitness_core_BE.Interfaces
         Task<List<Booking>> GetBookingsForCustomer(Guid customerId);
         Task<bool> CustomerHasActiveBookingForSession(Guid facilitySessionId, Guid customerId);
 
-        /// <summary>Unified roster query covering both Scheduled and AdHoc bookings -- backs
+        /// <summary>Unified roster query covering both Scheduled and WalkIn bookings -- backs
         /// GET api/client/bookings. All filters are optional/AND-combined.</summary>
         Task<List<Booking>> GetBookings(Guid clientId, Guid? facilityId, Guid? facilitySessionId, DateTime? fromUtc, DateTime? toUtc, string? status);
 

Interfaces/ICustomerSubscriptionRepository.cs

@@ -23,14 +23,31 @@ namespace Fitness_core_BE.Interfaces
         Task<CustomerCards?> GetCardByIdAsync(Guid cardId, CancellationToken ct = default);
         Task<CustomerSubscription?> GetCustomerSubscriptionById(Guid subscriptionId);
         Task<List<CustomerSubscription>> GetCustomerSubscriptionsByCustomerId(Guid customerId);
-        Task<CustomerSubscription?> GetActiveSubscriptionByCustomerId(Guid customerId);
+        /// <summary>True for an ordinary plan (no CustomerPlanClass links) or a class-linked
+        /// plan with GrantsGymAccess == true.</summary>
+        Task<bool> PlanGrantsGymAccessAsync(Guid customerPlanId, CancellationToken ct = default);
+
+        /// <summary>The customer's active subscription whose plan grants gym access, if any --
+        /// at most one can exist (enforced by HasActiveGymAccessPlanAsync at assignment time).
+        /// Primary-only, same as the old GetActiveSubscriptionByCustomerId this replaces.</summary>
+        Task<CustomerSubscription?> GetActiveGymAccessSubscriptionAsync(Guid customerId);
+
+        /// <summary>The customer's active subscription on this exact plan, if any -- the
+        /// idempotency check for re-assigning a class-only plan (which, unlike a gym plan,
+        /// doesn't block on ANY other active plan, only a duplicate of itself).</summary>
+        Task<CustomerSubscription?> GetActiveSubscriptionForPlanAsync(Guid customerId, Guid customerPlanId);
+
+        /// <summary>The subscription that covers booking a specific class, preferring one with
+        /// quota left this cycle. Null if none of the customer's active subscriptions link to
+        /// this class at all.</summary>
+        Task<CustomerSubscription?> GetActiveSubscriptionForClassAsync(Guid customerId, Guid facilityClassId);
 
         // Whether this customer is currently an active member (primary OR secondary/group) of
-        // ANY subscription at this gym. GetActiveSubscriptionByCustomerId only sees subscriptions
-        // where they're the primary -- this also catches a group co-member, so "one customer, one
-        // plan at a time" can be enforced everywhere a plan gets assigned, not just the primary
-        // path.
-        Task<bool> HasAnyActiveSubscriptionAsync(Guid customerId, CancellationToken ct = default);
+        // ANY gym-access subscription at this gym -- a class-only subscription never counts, so
+        // unlimited concurrent class-only subscriptions are allowed. "One customer, one
+        // GYM-ACCESS plan at a time" is enforced everywhere a gym plan gets assigned, not just
+        // the primary path.
+        Task<bool> HasActiveGymAccessPlanAsync(Guid customerId, CancellationToken ct = default);
 
         Task<SubscriptionMember> AddSubscriptionMemberAsync(SubscriptionMember member);
         Task<int> GetActiveMemberCountAsync(Guid subscriptionId);

Interfaces/IFacilityClassRepository.cs

@@ -0,0 +1,42 @@
+using Fitness_core_BE.Models;
+
+namespace Fitness_core_BE.Interfaces
+{
+    public interface IFacilityClassRepository
+    {
+        Task<FacilityClass> CreateFacilityClass(FacilityClass facilityClass);
+        Task<List<FacilityClass>> GetFacilityClasses(Guid clientId, bool includeInactive = false);
+        Task<FacilityClass?> GetFacilityClassById(Guid facilityClassId);
+        Task<FacilityClass> UpdateFacilityClass(FacilityClass facilityClass);
+
+        /// <summary>Active, non-Custom classes whose OccurrencesGeneratedThrough hasn't reached
+        /// the horizon yet -- Custom classes are never generated, their occurrences are always
+        /// written explicitly.</summary>
+        Task<List<FacilityClass>> GetClassesNeedingGenerationAsync(Guid clientId, DateTime horizon);
+
+        /// <summary>Existing occurrence start times for this class in [from, to) -- for
+        /// pre-generation dedup. The unique (FKFacilityClassId, StartTime) index is the actual
+        /// race-safety net; this just avoids the common sequential case needlessly retrying.</summary>
+        Task<HashSet<DateTime>> GetExistingOccurrenceStartTimesAsync(Guid facilityClassId, DateTime from, DateTime to);
+
+        Task AddOccurrencesAsync(IEnumerable<FacilitySession> occurrences);
+
+        Task<List<FacilitySession>> GetOccurrencesForClassAsync(Guid facilityClassId, bool includeCancelled);
+
+        /// <summary>Deletes occurrences that are both in the future and have zero Booking rows
+        /// of ANY status (a Cancelled booking still holds the FK, so it would fail the delete) --
+        /// the safe-to-regenerate set when a class's recurrence rule changes. Returns the count
+        /// deleted.</summary>
+        Task<int> DeleteFutureUnbookedOccurrencesAsync(Guid facilityClassId, DateTime nowUtc);
+
+        /// <summary>Confirmed, non-cancelled ad-hoc bookings whose window overlaps an active
+        /// (non-cancelled) class occurrence on the same facility -- surfaced to staff as a
+        /// conflict to resolve via the existing Reschedule flow, not auto-resolved.</summary>
+        Task<List<Booking>> GetSchedulingConflictsAsync(Guid clientId);
+
+        /// <summary>Links a newly-created CustomerPlan to the class it's sold against -- the
+        /// "Manage Plan" action's whole reason for being a class-scoped entry point rather than
+        /// the general Plans tab.</summary>
+        Task LinkPlanToClassAsync(Guid customerPlanId, Guid facilityClassId);
+    }
+}

Interfaces/IFacilityRepository.cs

@@ -12,9 +12,14 @@ namespace Fitness_core_BE.Interfaces
 
         Task<FacilitySession> CreateFacilitySession(FacilitySession session);
         Task<FacilitySession?> GetFacilitySessionById(Guid facilitySessionId);
-        Task<List<FacilitySession>> GetSessions(Guid clientId, Guid? facilityId, DateTime fromUtc, DateTime toUtc);
+        Task<List<FacilitySession>> GetSessions(Guid clientId, Guid? facilityId, DateTime fromUtc, DateTime toUtc, bool includeCancelled = false);
         Task<int> GetActiveBookingCount(Guid facilitySessionId);
-        Task<FacilitySession?> CancelFacilitySession(Guid facilitySessionId, Guid clientId);
+        Task<List<FacilitySession>> GetOverlappingActiveSessionsAsync(Guid facilityId, DateTime startUtc, DateTime endUtc);
+
+        /// <summary>"Mark not held" -- see FacilityService.CancelFacilitySession for the full
+        /// cascade this backs. Returns the session with its Bookings included so the caller can
+        /// cancel+refund each Confirmed one.</summary>
+        Task<FacilitySession?> MarkFacilitySessionNotHeldAsync(Guid facilitySessionId, Guid clientId, string? reason);
 
         // Device binding (absorbed from the old IPlaceRepo -- one AccessDevice per Facility).
         Task<AccessDevice?> GetDeviceByIdForClientAsync(Guid deviceId, Guid clientId);
@@ -30,15 +35,15 @@ namespace Fitness_core_BE.Interfaces
         Task<Dictionary<Guid, List<Guid>>> GetFacilityIdsByPlanIdsAsync(List<Guid> customerPlanIds);
         Task<Dictionary<Guid, string>> GetFacilityNamesByIdsAsync(List<Guid> facilityIds);
 
-        // AdHoc booking support (new). See TenantDbContext's Booking (FKFacilityId, StartTime,
+        // WalkIn booking support (new). See TenantDbContext's Booking (FKFacilityId, StartTime,
         // EndTime) index comment -- overlap is checked here rather than by a DB constraint.
-        /// <summary>Counts non-cancelled/non-completed AdHoc bookings on this facility whose
+        /// <summary>Counts non-cancelled/non-completed WalkIn bookings on this facility whose
         /// [StartTime, EndTime) overlaps the given window. Pass excludeBookingId when
         /// re-checking a booking being rescheduled, so it doesn't count against itself.</summary>
-        Task<int> GetOverlappingAdhocBookingCountAsync(Guid facilityId, DateTime startTime, DateTime endTime, Guid? excludeBookingId = null);
+        Task<int> GetOverlappingWalkInBookingCountAsync(Guid facilityId, DateTime startTime, DateTime endTime, Guid? excludeBookingId = null);
 
         /// <summary>Issues a row lock on the facility (SELECT ... FOR UPDATE) inside the caller's
-        /// already-open unit-of-work transaction, serializing concurrent AdHoc-slot claims on the
+        /// already-open unit-of-work transaction, serializing concurrent WalkIn-slot claims on the
         /// same facility so two overlapping bookings can't both pass the overlap-count check.</summary>
         Task LockFacilityForUpdateAsync(Guid facilityId);
     }

Interfaces/IInventoryRepository.cs

@@ -0,0 +1,44 @@
+using Fitness_core_BE.Models;
+
+namespace Fitness_core_BE.Interfaces
+{
+    public interface IInventoryRepository
+    {
+        // Products
+        Task<List<Product>> GetProducts(Guid clientId, bool includeInactive = false);
+        Task<Product?> GetProductById(Guid productId);
+        Task<Product> CreateProduct(Product product);
+        Task<Product> UpdateProduct(Product product);
+        /// <summary>Next sequential number for this client, e.g. 3 -&gt; "PRD-0004" -- Sku is
+        /// system-generated, never user-entered.</summary>
+        Task<int> GetNextProductSequence(Guid clientId);
+
+        // Product detail page: stock-movement history (GRN-in, Sale-out, Return-out).
+        Task<List<GoodsReceivedNoteItem>> GetGrnItemsForProduct(Guid productId);
+        Task<List<SaleItem>> GetSaleItemsForProduct(Guid productId);
+        Task<List<StockReturn>> GetStockReturnsForProduct(Guid productId);
+
+        // Suppliers
+        Task<List<Supplier>> GetSuppliers(Guid clientId, bool includeInactive = false);
+        Task<Supplier?> GetSupplierById(Guid supplierId);
+        Task<Supplier> CreateSupplier(Supplier supplier);
+
+        // GRN
+        Task<GoodsReceivedNote> CreateGrn(GoodsReceivedNote grn);
+        Task<List<GoodsReceivedNote>> GetGrns(Guid clientId);
+        Task<GoodsReceivedNote?> GetGrnById(Guid grnId);
+        /// <summary>Next sequential number for this client, e.g. 3 -&gt; "GRN-0004".</summary>
+        Task<int> GetNextGrnSequence(Guid clientId);
+
+        // Sales
+        Task<Sale> CreateSale(Sale sale);
+        Task<List<Sale>> GetSales(Guid clientId);
+        Task<Sale?> GetSaleById(Guid saleId);
+        Task<int> GetNextSaleSequence(Guid clientId);
+
+        // Returns
+        Task<StockReturn> CreateStockReturn(StockReturn stockReturn);
+        Task<List<StockReturn>> GetStockReturns(Guid clientId);
+        Task<StockReturn?> GetStockReturnById(Guid stockReturnId);
+    }
+}

Interfaces/Services/IBookingService.cs

@@ -1,21 +1,25 @@
+using Fitness_core_BE.Models;
 using Microsoft.AspNetCore.Http;
 
 namespace Fitness_core_BE.Interfaces.Services
 {
     public interface IBookingService
     {
+        /// <summary>Shared cancel+refund core -- see BookingService.CancelBookingCore.</summary>
+        Task CancelBookingCore(Booking booking);
+
         /// <summary>Logged-in member books a session against their own plan's allowance.</summary>
         Task<object> CreateMemberBooking(object payload, HttpContext httpContext);
 
         /// <summary>No membership at all -- pay-per-session, identity proof is the returned OTP.</summary>
         Task<object> CreateGuestBooking(object payload, HttpContext httpContext);
 
-        /// <summary>Member books an AdHoc-mode facility directly for an arbitrary time window, no
+        /// <summary>Member books a WalkIn-mode facility directly for an arbitrary time window, no
         /// pre-created session.</summary>
-        Task<object> CreateMemberAdhocBooking(object payload, HttpContext httpContext);
+        Task<object> CreateMemberWalkInBooking(object payload, HttpContext httpContext);
 
-        /// <summary>Guest/staff walk-in books an AdHoc-mode facility directly.</summary>
-        Task<object> CreateGuestAdhocBooking(object payload, HttpContext httpContext);
+        /// <summary>Guest/staff walk-in books a WalkIn-mode facility directly.</summary>
+        Task<object> CreateGuestWalkInBooking(object payload, HttpContext httpContext);
 
         /// <summary>Renders the public, unauthenticated confirmation page a booking's ShareUrl
         /// points to -- the "copy the link and share it" receipt. Returns null if not found, so
@@ -36,7 +40,7 @@ namespace Fitness_core_BE.Interfaces.Services
         /// no cancel/recreate needed. Guest bookings only.</summary>
         Task<object> ReassignBooking(object payload, HttpContext httpContext);
 
-        /// <summary>Staff moves a Confirmed booking to a different time (AdHoc) or session
+        /// <summary>Staff moves a Confirmed booking to a different time (WalkIn) or session
         /// (Scheduled), only onto a slot with room.</summary>
         Task<object> RescheduleBooking(object payload, HttpContext httpContext);
 

Interfaces/Services/IClassService.cs

@@ -0,0 +1,18 @@
+namespace Fitness_core_BE.Interfaces.Services
+{
+    public interface IClassService
+    {
+        Task<object> GetFacilityClasses(object payload, HttpContext httpContext);
+        Task<object> CreateFacilityClass(object payload, HttpContext httpContext);
+        Task<object> UpdateFacilityClass(object payload, HttpContext httpContext);
+        Task<object> GetOccurrences(object payload, HttpContext httpContext);
+        Task<object> GetSchedulingConflicts(object payload, HttpContext httpContext);
+
+        /// <summary>Lazy occurrence generation, mirroring the existing SweepOverdueBookingsAsync
+        /// convention (no background job) -- generates the missing FacilitySession rows up to
+        /// "today + 8 weeks" for every active, non-Custom class whose watermark hasn't reached
+        /// it yet, and advances the watermark. Called from the top of FacilityService.GetSessions,
+        /// the one read path everything already goes through.</summary>
+        Task EnsureOccurrencesGeneratedAsync(Guid clientId);
+    }
+}

Interfaces/Services/IInventoryService.cs

@@ -0,0 +1,28 @@
+namespace Fitness_core_BE.Interfaces.Services
+{
+    public interface IInventoryService
+    {
+        Task<object> GetProducts(object payload, HttpContext httpContext);
+        Task<object> GetProductById(object payload, HttpContext httpContext);
+        Task<object> CreateProduct(object payload, HttpContext httpContext);
+        Task<object> UpdateProduct(object payload, HttpContext httpContext);
+        Task<object> UploadProductImage(Guid productId, IFormFile image, HttpContext httpContext);
+
+        Task<object> GetSuppliers(object payload, HttpContext httpContext);
+        Task<object> CreateSupplier(object payload, HttpContext httpContext);
+
+        Task<object> CreateGrn(object payload, HttpContext httpContext);
+        Task<object> GetGrns(object payload, HttpContext httpContext);
+        Task<object> GetGrnById(object payload, HttpContext httpContext);
+
+        Task<object> CreateSale(object payload, HttpContext httpContext);
+        Task<object> GetSales(object payload, HttpContext httpContext);
+        Task<object> GetSaleById(object payload, HttpContext httpContext);
+
+        Task<object> CreateStockReturn(object payload, HttpContext httpContext);
+        Task<object> GetStockReturns(object payload, HttpContext httpContext);
+        Task<object> GetStockReturnById(object payload, HttpContext httpContext);
+
+        Task<object> GetStockMovements(object payload, HttpContext httpContext);
+    }
+}

Models/Booking.cs

@@ -4,7 +4,7 @@ using System.ComponentModel.DataAnnotations.Schema;
 namespace Fitness_core_BE.Models
 {
     /// <summary>One reservation against a Facility — either a Scheduled-mode booking against a
-    /// pre-created FacilitySession (many bookings share one capacity pool), or an AdHoc-mode
+    /// pre-created FacilitySession (many bookings share one capacity pool), or a WalkIn-mode
     /// booking that claims one of the Facility's NumberOfUnits directly for an arbitrary time
     /// window, no session needed. Either an existing member using a CustomerPlan session
     /// allowance (FKCustomerId set, IsGuest = false) or a non-member who booked online and pays
@@ -16,28 +16,28 @@ namespace Fitness_core_BE.Models
         [Key]
         public Guid BookingId { get; set; }
 
-        /// <summary>Null for an AdHoc booking (no pre-created session).</summary>
+        /// <summary>Null for a WalkIn booking (no pre-created session).</summary>
         public Guid? FKFacilitySessionId { get; set; }
         [ForeignKey(nameof(FKFacilitySessionId))]
         public FacilitySession? FacilitySession { get; set; }
 
         /// <summary>Always set, for both modes -- copied from FacilitySession.FKFacilityId at
-        /// creation (Scheduled) or the booked facility directly (AdHoc). Every place that needs
+        /// creation (Scheduled) or the booked facility directly (WalkIn). Every place that needs
         /// "which facility / what time window" reads these (and StartTime/EndTime below)
-        /// uniformly instead of reaching through FacilitySession, which doesn't exist for AdHoc
+        /// uniformly instead of reaching through FacilitySession, which doesn't exist for WalkIn
         /// bookings.</summary>
         public Guid FKFacilityId { get; set; }
         [ForeignKey(nameof(FKFacilityId))]
         public Facility Facility { get; set; }
 
         /// <summary>Copied from FacilitySession.StartTime (Scheduled) or the requested start
-        /// (AdHoc) at creation; updated in place by Reschedule.</summary>
+        /// (WalkIn) at creation; updated in place by Reschedule.</summary>
         public DateTime StartTime { get; set; }
         /// <summary>Same pattern as StartTime.</summary>
         public DateTime EndTime { get; set; }
 
-        /// <summary>Informational headcount for an AdHoc booking (e.g. "how many will come") --
-        /// never enforced as a capacity mechanic; each AdHoc booking claims one whole unit
+        /// <summary>Informational headcount for a WalkIn booking (e.g. "how many will come") --
+        /// never enforced as a capacity mechanic; each WalkIn booking claims one whole unit
         /// regardless of party size. Null for Scheduled bookings.</summary>
         public int? PartySize { get; set; }
 

Models/CustomerPlan.cs

@@ -63,5 +63,14 @@ namespace Fitness_core_BE.Models
 
         public bool IsActive { get; set; } = true;
         public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
+
+        /// <summary>Meaningful only for a plan linked to one or more classes (via
+        /// CustomerPlanClass) -- never consulted for an ordinary plan with no class links,
+        /// which always grants gym access regardless of this flag's stored value. Lets a class
+        /// plan optionally also grant general gym-floor access ("class + gym" as one product)
+        /// instead of class-only. Migration default true (so every pre-existing plan, which has
+        /// no class links, keeps behaving exactly as before); new class plans default this to
+        /// false in the UI.</summary>
+        public bool GrantsGymAccess { get; set; } = true;
     }
 }

Models/CustomerPlanClass.cs

@@ -0,0 +1,23 @@
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace Fitness_core_BE.Models
+{
+    /// <summary>Many-to-many join: which FacilityClass(es) a CustomerPlan is sold against. A
+    /// plan with no rows here is an ordinary gym plan, completely unaffected by the Classes
+    /// feature -- CustomerPlan.GrantsGymAccess is never consulted for it. Structurally identical
+    /// to CustomerPlanFacility.</summary>
+    public class CustomerPlanClass
+    {
+        [Key]
+        public Guid CustomerPlanClassId { get; set; }
+
+        public Guid FKCustomerPlanId { get; set; }
+        [ForeignKey(nameof(FKCustomerPlanId))]
+        public CustomerPlan CustomerPlan { get; set; } = null!;
+
+        public Guid FKFacilityClassId { get; set; }
+        [ForeignKey(nameof(FKFacilityClassId))]
+        public FacilityClass FacilityClass { get; set; } = null!;
+    }
+}

Models/Facility.cs

@@ -21,25 +21,30 @@ namespace Fitness_core_BE.Models
         [MaxLength(128)]
         public string Name { get; set; } = string.Empty;
 
-        /// <summary>"Scheduled" | "AdHoc". Scheduled: staff pre-creates fixed-time
-        /// FacilitySessions that many bookings share one capacity pool against (classes).
-        /// AdHoc: a booking claims one of NumberOfUnits identical units directly for an
-        /// arbitrary time window, no pre-created session needed (courts/pool).</summary>
-        public string BookingMode { get; set; } = "Scheduled";
+        /// <summary>Staff pre-creates fixed-time FacilitySessions (classes) that many bookings
+        /// share one capacity pool against. Independent of SupportsBooking -- both can be true,
+        /// e.g. a court that hosts a scheduled class AND accepts ad-hoc walk-in bookings outside
+        /// class hours.</summary>
+        public bool SupportsClasses { get; set; } = true;
+
+        /// <summary>A booking can claim one of NumberOfUnits identical units directly for an
+        /// arbitrary time window, no pre-created session needed (courts/pool). At least one of
+        /// SupportsClasses/SupportsBooking must be true.</summary>
+        public bool SupportsBooking { get; set; } = false;
 
         [MaxLength(500)]
         public string? Description { get; set; }
 
-        /// <summary>Default per-session headcount limit when BookingMode == "Scheduled"; a
-        /// specific FacilitySession can override.</summary>
+        /// <summary>Default per-session headcount limit when SupportsClasses; a specific
+        /// FacilitySession can override.</summary>
         public int DefaultCapacity { get; set; } = 1;
 
-        /// <summary>Number of identical, independently-bookable units when BookingMode ==
-        /// "AdHoc" (e.g. 3 for "3 courts") -- availability is this minus overlapping
-        /// non-cancelled/non-completed AdHoc bookings in the requested window.</summary>
+        /// <summary>Number of identical, independently-bookable units when SupportsBooking (e.g.
+        /// 3 for "3 courts") -- availability is this minus overlapping non-cancelled/
+        /// non-completed WalkIn bookings in the requested window.</summary>
         public int NumberOfUnits { get; set; } = 1;
 
-        /// <summary>Hourly rate used to compute a guest AdHoc booking's suggested AmountCharged
+        /// <summary>Hourly rate used to compute a guest WalkIn booking's suggested AmountCharged
         /// (PricePerHour * duration-in-hours) at creation time.</summary>
         public decimal PricePerHour { get; set; } = 0m;
 

Models/FacilityClass.cs

@@ -0,0 +1,71 @@
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace Fitness_core_BE.Models
+{
+    /// <summary>A recurring class definition (Zumba, Yoga) on a Facility that SupportsClasses --
+    /// generates FacilitySession rows ("occurrences") on a schedule. Replaces manually creating
+    /// one-off FacilitySession rows from the Bookings page for anything that recurs.</summary>
+    public class FacilityClass
+    {
+        [Key]
+        public Guid FacilityClassId { get; set; }
+
+        public Guid FKClientId { get; set; }
+        [ForeignKey(nameof(FKClientId))]
+        public Client Client { get; set; }
+
+        public Guid FKFacilityId { get; set; }
+        [ForeignKey(nameof(FKFacilityId))]
+        public Facility Facility { get; set; }
+
+        [MaxLength(128)]
+        public string Name { get; set; } = string.Empty;
+
+        [MaxLength(500)]
+        public string? Description { get; set; }
+
+        /// <summary>"Daily" | "Weekly" | "Monthly" | "Custom". Custom skips every rule field
+        /// below -- occurrences are written explicitly (as FacilitySession rows) at creation/
+        /// edit time with their own dates, instead of being generated from a rule.</summary>
+        [MaxLength(20)]
+        public string RecurrenceType { get; set; } = "Weekly";
+
+        /// <summary>The class's daily time window, in the facility's local time (not UTC) -- the
+        /// generator converts to UTC per-occurrence using the club's timezone. Unused (0) for
+        /// Custom, where each occurrence's own FacilitySession.StartTime/EndTime is explicit.</summary>
+        public TimeSpan StartTimeOfDay { get; set; }
+        public int DurationMinutes { get; set; } = 60;
+
+        /// <summary>Weekly only. Bit flags, Sunday = 1 (bit 0) through Saturday = 64 (bit 6).</summary>
+        public int WeekDaysMask { get; set; } = 0;
+
+        /// <summary>Monthly only. Comma-separated day-of-month list, e.g. "1,15".</summary>
+        [MaxLength(200)]
+        public string? MonthDays { get; set; }
+
+        /// <summary>Unused for Custom (occurrences are explicit, not generated from a range).</summary>
+        public DateTime SeriesStartDate { get; set; } = DateTime.UtcNow.Date;
+        /// <summary>Null = ongoing, no end date. Unused for Custom.</summary>
+        public DateTime? SeriesEndDate { get; set; }
+
+        /// <summary>Null = unlimited (see IsUnlimitedCapacity); otherwise the per-occurrence
+        /// headcount cap, same meaning as Facility.DefaultCapacity/FacilitySession.Capacity.</summary>
+        public int? Capacity { get; set; }
+
+        /// <summary>When true, Capacity is ignored and every generated occurrence has no cap --
+        /// a distinct flag rather than a sentinel value, since FacilitySession.Capacity == null
+        /// already means "use the facility default," and int.MaxValue would overflow the
+        /// checked Sum() in FacilityService.GetAvailability.</summary>
+        public bool IsUnlimitedCapacity { get; set; } = false;
+
+        public bool IsActive { get; set; } = true;
+
+        /// <summary>Watermark: occurrences have been generated through this date already.
+        /// Advanced by FacilityService.EnsureOccurrencesGeneratedAsync; never consulted for
+        /// Custom classes (their occurrences are all written explicitly, never generated).</summary>
+        public DateTime OccurrencesGeneratedThrough { get; set; } = DateTime.UtcNow.Date;
+
+        public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
+    }
+}

Models/FacilitySession.cs

@@ -22,12 +22,30 @@ namespace Fitness_core_BE.Models
         public DateTime StartTime { get; set; }
         public DateTime EndTime { get; set; }
 
-        /// <summary>Overrides Facility.DefaultCapacity when set; null = use the facility default.</summary>
+        /// <summary>Overrides Facility.DefaultCapacity when set; null = use the facility default.
+        /// Ignored when IsUnlimitedCapacity is true.</summary>
         public int? Capacity { get; set; }
 
+        /// <summary>Copied from FacilityClass.IsUnlimitedCapacity at generation time (or set
+        /// directly for a manually-created session) -- see that flag's doc comment for why this
+        /// isn't just a Capacity sentinel value.</summary>
+        public bool IsUnlimitedCapacity { get; set; } = false;
+
         public bool IsCancelled { get; set; } = false;
         public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
 
+        /// <summary>Null for a manually-created session (the pre-Classes path, unaffected).
+        /// Set for a class occurrence -- which FacilityClass generated or explicitly added it.</summary>
+        public Guid? FKFacilityClassId { get; set; }
+        [ForeignKey(nameof(FKFacilityClassId))]
+        public FacilityClass? FacilityClass { get; set; }
+
+        /// <summary>Set together by FacilityService's "mark not held" cascade (which replaces
+        /// the old bare-IsCancelled CancelFacilitySession) -- null means this occurrence is
+        /// either still scheduled or was never a class occurrence at all.</summary>
+        public string? NotHeldReason { get; set; }
+        public DateTime? NotHeldAt { get; set; }
+
         public virtual ICollection<Booking> Bookings { get; set; }
     }
 }

Models/GoodsReceivedNote.cs

@@ -0,0 +1,55 @@
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace Fitness_core_BE.Models
+{
+    /// <summary>Stock coming in, optionally from a Supplier -- some GRNs don't have one (e.g.
+    /// self-produced stock, or the supplier just isn't on file). Creating one increments each
+    /// line's Product.QuantityOnHand and overwrites Product.CostPrice with that line's UnitCost
+    /// (a simple latest-cost approach, not a weighted average).</summary>
+    public class GoodsReceivedNote
+    {
+        [Key]
+        public Guid GrnId { get; set; }
+
+        public Guid FKClientId { get; set; }
+        [ForeignKey(nameof(FKClientId))]
+        public Client Client { get; set; }
+
+        public Guid? FKSupplierId { get; set; }
+        [ForeignKey(nameof(FKSupplierId))]
+        public Supplier? Supplier { get; set; }
+
+        [MaxLength(32)]
+        public string GrnNumber { get; set; } = string.Empty;
+
+        public DateTime ReceivedAt { get; set; } = DateTime.UtcNow;
+
+        [MaxLength(300)]
+        public string? Notes { get; set; }
+
+        public decimal TotalAmount { get; set; } = 0m;
+
+        public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
+
+        public virtual ICollection<GoodsReceivedNoteItem> Items { get; set; } = new List<GoodsReceivedNoteItem>();
+    }
+
+    public class GoodsReceivedNoteItem
+    {
+        [Key]
+        public Guid GrnItemId { get; set; }
+
+        public Guid FKGrnId { get; set; }
+        [ForeignKey(nameof(FKGrnId))]
+        public GoodsReceivedNote? Grn { get; set; }
+
+        public Guid FKProductId { get; set; }
+        [ForeignKey(nameof(FKProductId))]
+        public Product? Product { get; set; }
+
+        public decimal Quantity { get; set; }
+        public decimal UnitCost { get; set; }
+        public decimal LineTotal { get; set; }
+    }
+}

Models/Product.cs

@@ -0,0 +1,43 @@
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace Fitness_core_BE.Models
+{
+    /// <summary>A stocked item sold at the gym (snacks, supplements, merchandise). QuantityOnHand
+    /// is a maintained running balance -- adjusted by GoodsReceivedNoteItem (+), SaleItem (-) and
+    /// StockReturn (-) -- not computed from those tables on every read.</summary>
+    public class Product
+    {
+        [Key]
+        public Guid ProductId { get; set; }
+
+        public Guid FKClientId { get; set; }
+        [ForeignKey(nameof(FKClientId))]
+        public Client Client { get; set; }
+
+        [MaxLength(128)]
+        public string Name { get; set; } = string.Empty;
+
+        [MaxLength(64)]
+        public string? Sku { get; set; }
+
+        /// <summary>Relative /Uploads path to the product's photo (same convention as
+        /// ClientBusiness.BusinessLogoId) -- null when no image has been uploaded.</summary>
+        [MaxLength(300)]
+        public string? ImageId { get; set; }
+
+        [MaxLength(20)]
+        public string UnitOfMeasure { get; set; } = "pcs";
+
+        /// <summary>Set from the most recent GRN line's UnitCost -- a simple latest-cost
+        /// approach, not a weighted average.</summary>
+        public decimal CostPrice { get; set; } = 0m;
+
+        public decimal SellingPrice { get; set; } = 0m;
+
+        public decimal QuantityOnHand { get; set; } = 0m;
+
+        public bool IsActive { get; set; } = true;
+        public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
+    }
+}

Models/Sale.cs

@@ -0,0 +1,59 @@
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace Fitness_core_BE.Models
+{
+    /// <summary>Stock going out to a customer. Creating one decrements each line's
+    /// Product.QuantityOnHand -- the whole sale is rejected up front if any line would go
+    /// negative (no backorders).</summary>
+    public class Sale
+    {
+        [Key]
+        public Guid SaleId { get; set; }
+
+        public Guid FKClientId { get; set; }
+        [ForeignKey(nameof(FKClientId))]
+        public Client Client { get; set; }
+
+        [MaxLength(32)]
+        public string SaleNumber { get; set; } = string.Empty;
+
+        public DateTime SoldAt { get; set; } = DateTime.UtcNow;
+
+        /// <summary>"Cash" | "Bank" -- same convention as Booking.PaymentMethod.</summary>
+        [MaxLength(20)]
+        public string PaymentMethod { get; set; } = "Cash";
+
+        /// <summary>Optional link to a registered member, purely for identification -- mirrors
+        /// Booking.FKCustomerId (see BookingService.ResolveOptionalCustomerLinkAsync). A walk-in
+        /// buyer leaves this null and uses CustomerName instead.</summary>
+        public Guid? FKCustomerId { get; set; }
+
+        [MaxLength(128)]
+        public string? CustomerName { get; set; }
+
+        public decimal TotalAmount { get; set; } = 0m;
+
+        public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
+
+        public virtual ICollection<SaleItem> Items { get; set; } = new List<SaleItem>();
+    }
+
+    public class SaleItem
+    {
+        [Key]
+        public Guid SaleItemId { get; set; }
+
+        public Guid FKSaleId { get; set; }
+        [ForeignKey(nameof(FKSaleId))]
+        public Sale? Sale { get; set; }
+
+        public Guid FKProductId { get; set; }
+        [ForeignKey(nameof(FKProductId))]
+        public Product? Product { get; set; }
+
+        public decimal Quantity { get; set; }
+        public decimal UnitPrice { get; set; }
+        public decimal LineTotal { get; set; }
+    }
+}

Models/StockReturn.cs

@@ -0,0 +1,56 @@
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace Fitness_core_BE.Models
+{
+    /// <summary>A stock adjustment -- expired, damaged, lost, sent back to the supplier, handed
+    /// back by a customer, or anything else (Category == "Other"). Direction depends on the
+    /// category: "CustomerReturn" is the one case that ADDS back to Product.QuantityOnHand (the
+    /// item physically comes back after an earlier sale already removed it); every other
+    /// category REMOVES from it (stock we currently hold being written off or sent away). Amount
+    /// is auto-computed (Quantity * Product.CostPrice at the moment of the return) for the
+    /// Profit &amp; Loss impact. FKSaleId/FKGrnId are both optional, independent traceability
+    /// links to the specific Sale or GRN this return relates to -- many returns (e.g. damaged
+    /// stock sitting on the shelf) don't trace back to either.</summary>
+    public class StockReturn
+    {
+        [Key]
+        public Guid StockReturnId { get; set; }
+
+        public Guid FKClientId { get; set; }
+        [ForeignKey(nameof(FKClientId))]
+        public Client Client { get; set; }
+
+        public Guid FKProductId { get; set; }
+        [ForeignKey(nameof(FKProductId))]
+        public Product? Product { get; set; }
+
+        public decimal Quantity { get; set; }
+
+        /// <summary>"Expired" | "Damaged" | "Lost" | "SupplierReturn" | "CustomerReturn" | "Other".
+        /// Only "CustomerReturn" adds back to stock -- see class doc comment.</summary>
+        [MaxLength(20)]
+        public string Category { get; set; } = "Other";
+
+        /// <summary>Optional -- e.g. a customer return that came from a specific sale.</summary>
+        public Guid? FKSaleId { get; set; }
+        [ForeignKey(nameof(FKSaleId))]
+        public Sale? Sale { get; set; }
+
+        /// <summary>Optional -- e.g. stock sent back to the supplier from a specific GRN.</summary>
+        public Guid? FKGrnId { get; set; }
+        [ForeignKey(nameof(FKGrnId))]
+        public GoodsReceivedNote? Grn { get; set; }
+
+        [MaxLength(300)]
+        public string? Notes { get; set; }
+
+        public DateTime ReturnedAt { get; set; } = DateTime.UtcNow;
+
+        /// <summary>Quantity * Product.CostPrice at the moment of the return -- snapshotted so
+        /// it doesn't drift later if CostPrice changes.</summary>
+        public decimal Amount { get; set; } = 0m;
+
+        public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
+    }
+}

Models/Supplier.cs

@@ -0,0 +1,31 @@
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace Fitness_core_BE.Models
+{
+    /// <summary>Who stock is received from on a GoodsReceivedNote.</summary>
+    public class Supplier
+    {
+        [Key]
+        public Guid SupplierId { get; set; }
+
+        public Guid FKClientId { get; set; }
+        [ForeignKey(nameof(FKClientId))]
+        public Client Client { get; set; }
+
+        [MaxLength(128)]
+        public string Name { get; set; } = string.Empty;
+
+        [MaxLength(32)]
+        public string? Phone { get; set; }
+
+        [MaxLength(128)]
+        public string? Email { get; set; }
+
+        [MaxLength(300)]
+        public string? Address { get; set; }
+
+        public bool IsActive { get; set; } = true;
+        public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
+    }
+}

Program.cs

@@ -141,7 +141,9 @@ builder.Services.AddScoped<IOverdueLockRepository, OverdueLockRepository>();
 builder.Services.AddScoped<IPlatformBillingRepository, PlatformBillingRepository>();
 builder.Services.AddScoped<ICustomerNotificationRepository, CustomerNotificationRepository>();
 builder.Services.AddScoped<IFacilityRepository, FacilityRepository>();
+builder.Services.AddScoped<IFacilityClassRepository, FacilityClassRepository>();
 builder.Services.AddScoped<IBookingRepository, BookingRepository>();
+builder.Services.AddScoped<IInventoryRepository, InventoryRepository>();
 builder.Services.AddScoped<ITimeBankCardRepository, TimeBankCardRepository>();
 builder.Services.AddScoped<IRfidTagRepository, RfidTagRepository>();
 
@@ -163,6 +165,8 @@ builder.Services.AddScoped<ICustomerInvoiceService, CustomerInvoiceService>();
 builder.Services.AddScoped<ICustomerSubscriptionService, CustomerSubscriptionService>();
 builder.Services.AddScoped<IFacilityService, FacilityService>();
 builder.Services.AddScoped<IBookingService, BookingService>();
+builder.Services.AddScoped<IClassService, ClassService>();
+builder.Services.AddScoped<IInventoryService, InventoryService>();
 builder.Services.AddScoped<IRfidTagService, RfidTagService>();
 builder.Services.AddScoped<ITimeBankCardService, TimeBankCardService>();
 builder.Services.AddScoped<IBootstrapService, BootstrapService>();

Repos/ClientRepository.cs

@@ -354,12 +354,22 @@ namespace Fitness_core_BE.Repos
         // Unlike CustomerSubscription.FKCustomerId (which only ever points at the primary
         // member), this resolves the caller's own SubscriptionMember row whether they're
         // the primary or a secondary member of a group subscription.
+        // Both callers (ClientService.ChangeCustomerMembershipPlan,
+        // SubscriptionRenewalApprovalService.ChangePlanAsync) reject a Group-scope new plan and
+        // are conceptually "swap the member's individual gym plan" -- so this must resolve to
+        // their GYM-ACCESS subscription specifically, not just whichever active subscription
+        // happens to be most recently created. Without this filter, a member holding both a gym
+        // plan and a class-only plan would have their class subscription silently deactivated
+        // and replaced instead of their gym one, once a class subscription could outrank it by
+        // CreatedAt.
         public async Task<SubscriptionMember?> GetActiveMembershipForCustomerAsync(Guid customerId, CancellationToken ct = default)
         {
             return await _dbContext.SubscriptionMembers
                 .Include(m => m.Subscription)
                     .ThenInclude(s => s.CustomerPlan)
                 .Where(m => m.FKCustomerId == customerId && m.IsActive && m.Subscription.IsActive)
+                .Where(m => !_dbContext.CustomerPlanClasses.Any(c => c.FKCustomerPlanId == m.Subscription.FKCustomerPlanId)
+                    || m.Subscription.CustomerPlan.GrantsGymAccess)
                 .OrderByDescending(m => m.Subscription.CreatedAt)
                 .FirstOrDefaultAsync(ct);
         }

Repos/CustomerRepository.cs

@@ -116,7 +116,7 @@ namespace Fitness_core_BE.Repos
         }
 
         // Staff picking an existing member to link a walk-in booking to (identification only,
-        // see BookingService.CreateGuestBooking/CreateGuestAdhocBooking) -- tenant-scoped by
+        // see BookingService.CreateGuestBooking/CreateGuestWalkInBooking) -- tenant-scoped by
         // construction, same as FindActiveLinkByIdentifierAsync above.
         public Task<TenantCustomerLink?> GetTenantCustomerLinkById(Guid id)
             => _context.TenantCustomerLink

Repos/CustomerSubscriptionRepository.cs

@@ -134,23 +134,69 @@ namespace Fitness_core_BE.Repos
                 .ToListAsync();
         }
 
-        public async Task<CustomerSubscription?> GetActiveSubscriptionByCustomerId(Guid customerId)
+        // A plan with no CustomerPlanClass links is an ordinary gym plan -- GrantsGymAccess is
+        // never consulted for it (always true in effect). A class-linked plan only grants gym
+        // access when GrantsGymAccess is explicitly set. Reused by every gym-access query below.
+        private IQueryable<CustomerPlan> GymAccessPlans() => _context.CustomerPlans.Where(p =>
+            !_context.CustomerPlanClasses.Any(c => c.FKCustomerPlanId == p.CustomerPlanId) || p.GrantsGymAccess);
+
+        public Task<bool> PlanGrantsGymAccessAsync(Guid customerPlanId, CancellationToken ct = default)
+            => GymAccessPlans().AnyAsync(p => p.CustomerPlanId == customerPlanId, ct);
+
+        public async Task<CustomerSubscription?> GetActiveGymAccessSubscriptionAsync(Guid customerId)
         {
             return await _context.CustomerSubscriptions
                 .Include(s => s.TenantCustomerLink)
                 .Include(s => s.CustomerPlan)
                 .Where(s => s.FKCustomerId == customerId && s.IsActive)
+                .Where(s => GymAccessPlans().Any(p => p.CustomerPlanId == s.FKCustomerPlanId))
                 .OrderByDescending(s => s.CreatedAt)
                 .FirstOrDefaultAsync();
         }
 
+        public async Task<CustomerSubscription?> GetActiveSubscriptionForPlanAsync(Guid customerId, Guid customerPlanId)
+        {
+            return await _context.CustomerSubscriptions
+                .Include(s => s.CustomerPlan)
+                .Where(s => s.FKCustomerId == customerId && s.IsActive && s.FKCustomerPlanId == customerPlanId)
+                .OrderByDescending(s => s.CreatedAt)
+                .FirstOrDefaultAsync();
+        }
+
+        /// <summary>Resolves which of the customer's (possibly several) active subscriptions
+        /// covers a specific class, preferring one that still has quota left this cycle over one
+        /// that's already exhausted it -- two different plans can link the same class.</summary>
+        public async Task<CustomerSubscription?> GetActiveSubscriptionForClassAsync(Guid customerId, Guid facilityClassId)
+        {
+            var candidates = await _context.CustomerSubscriptions
+                .Include(s => s.CustomerPlan)
+                .Where(s => s.FKCustomerId == customerId && s.IsActive)
+                .Where(s => _context.CustomerPlanClasses.Any(c =>
+                    c.FKCustomerPlanId == s.FKCustomerPlanId && c.FKFacilityClassId == facilityClassId))
+                .OrderByDescending(s => s.CreatedAt)
+                .ToListAsync();
+
+            bool HasQuota(CustomerSubscription s)
+            {
+                if (!s.CustomerPlan.SessionsPerCycle.HasValue) return true;
+                var carriedOver = s.SessionsCarriedOverExpiresAt.HasValue && s.SessionsCarriedOverExpiresAt.Value < DateTime.UtcNow
+                    ? 0 : s.SessionsCarriedOver;
+                return s.SessionsUsedThisCycle < s.CustomerPlan.SessionsPerCycle.Value + carriedOver;
+            }
+
+            return candidates.FirstOrDefault(HasQuota) ?? candidates.FirstOrDefault();
+        }
+
         // SubscriptionMembers always has a row for the primary too (CustomerSubscriptionFactory
         // adds it alongside the CustomerSubscription itself), so this one query covers both
-        // "primary somewhere" and "secondary/group member somewhere" in a single check.
-        public Task<bool> HasAnyActiveSubscriptionAsync(Guid customerId, CancellationToken ct = default)
+        // "primary somewhere" and "secondary/group member somewhere" in a single check. Scoped
+        // to gym-access plans only -- a class-only subscription never blocks a second one via
+        // this check (unlimited concurrent class-only subscriptions are allowed).
+        public Task<bool> HasActiveGymAccessPlanAsync(Guid customerId, CancellationToken ct = default)
         {
             return _context.SubscriptionMembers.AnyAsync(m =>
-                m.FKCustomerId == customerId && m.IsActive && m.Subscription.IsActive, ct);
+                m.FKCustomerId == customerId && m.IsActive && m.Subscription.IsActive &&
+                GymAccessPlans().Any(p => p.CustomerPlanId == m.Subscription.FKCustomerPlanId), ct);
         }
 
         // ---------- Group membership ----------

Repos/FacilityClassRepository.cs

@@ -0,0 +1,132 @@
+using Fitness_core_BE.Interfaces;
+using Fitness_core_BE.Models;
+using Microsoft.EntityFrameworkCore;
+
+namespace Fitness_core_BE.Repos
+{
+    public class FacilityClassRepository : IFacilityClassRepository
+    {
+        private readonly TenantDbContext _context;
+
+        public FacilityClassRepository(TenantDbContext context)
+        {
+            _context = context;
+        }
+
+        public async Task<FacilityClass> CreateFacilityClass(FacilityClass facilityClass)
+        {
+            facilityClass.FacilityClassId = Guid.NewGuid();
+            facilityClass.CreatedAt = DateTime.UtcNow;
+            facilityClass.IsActive = true;
+
+            _context.FacilityClasses.Add(facilityClass);
+            return facilityClass;
+        }
+
+        public async Task<List<FacilityClass>> GetFacilityClasses(Guid clientId, bool includeInactive = false)
+        {
+            var query = _context.FacilityClasses
+                .Include(fc => fc.Facility)
+                .Where(fc => fc.FKClientId == clientId);
+            if (!includeInactive)
+                query = query.Where(fc => fc.IsActive);
+
+            return await query.OrderBy(fc => fc.Name).ToListAsync();
+        }
+
+        public Task<FacilityClass?> GetFacilityClassById(Guid facilityClassId)
+            => _context.FacilityClasses
+                .Include(fc => fc.Facility)
+                .FirstOrDefaultAsync(fc => fc.FacilityClassId == facilityClassId);
+
+        public async Task<FacilityClass> UpdateFacilityClass(FacilityClass facilityClass)
+        {
+            var existing = await _context.FacilityClasses.FindAsync(facilityClass.FacilityClassId)
+                ?? throw new KeyNotFoundException("Class not found");
+
+            existing.Name = facilityClass.Name;
+            existing.Description = facilityClass.Description;
+            existing.RecurrenceType = facilityClass.RecurrenceType;
+            existing.StartTimeOfDay = facilityClass.StartTimeOfDay;
+            existing.DurationMinutes = facilityClass.DurationMinutes;
+            existing.WeekDaysMask = facilityClass.WeekDaysMask;
+            existing.MonthDays = facilityClass.MonthDays;
+            existing.SeriesStartDate = facilityClass.SeriesStartDate;
+            existing.SeriesEndDate = facilityClass.SeriesEndDate;
+            existing.Capacity = facilityClass.Capacity;
+            existing.IsUnlimitedCapacity = facilityClass.IsUnlimitedCapacity;
+            existing.IsActive = facilityClass.IsActive;
+            existing.OccurrencesGeneratedThrough = facilityClass.OccurrencesGeneratedThrough;
+
+            return existing;
+        }
+
+        public Task<List<FacilityClass>> GetClassesNeedingGenerationAsync(Guid clientId, DateTime horizon)
+            => _context.FacilityClasses
+                .Where(fc => fc.FKClientId == clientId && fc.IsActive && fc.RecurrenceType != "Custom"
+                    && fc.OccurrencesGeneratedThrough < horizon)
+                .ToListAsync();
+
+        public async Task<HashSet<DateTime>> GetExistingOccurrenceStartTimesAsync(Guid facilityClassId, DateTime from, DateTime to)
+        {
+            var times = await _context.FacilitySessions
+                .Where(s => s.FKFacilityClassId == facilityClassId && s.StartTime >= from && s.StartTime < to)
+                .Select(s => s.StartTime)
+                .ToListAsync();
+            return times.ToHashSet();
+        }
+
+        public async Task AddOccurrencesAsync(IEnumerable<FacilitySession> occurrences)
+        {
+            var list = occurrences.ToList();
+            foreach (var occurrence in list)
+            {
+                occurrence.FacilitySessionId = Guid.NewGuid();
+                occurrence.CreatedAt = DateTime.UtcNow;
+                occurrence.IsCancelled = false;
+            }
+            await _context.FacilitySessions.AddRangeAsync(list);
+        }
+
+        public Task<List<FacilitySession>> GetOccurrencesForClassAsync(Guid facilityClassId, bool includeCancelled)
+        {
+            var query = _context.FacilitySessions.Where(s => s.FKFacilityClassId == facilityClassId);
+            if (!includeCancelled)
+                query = query.Where(s => !s.IsCancelled);
+
+            return query.OrderByDescending(s => s.StartTime).ToListAsync();
+        }
+
+        public async Task<int> DeleteFutureUnbookedOccurrencesAsync(Guid facilityClassId, DateTime nowUtc)
+        {
+            var candidates = await _context.FacilitySessions
+                .Where(s => s.FKFacilityClassId == facilityClassId && s.StartTime > nowUtc)
+                .Where(s => !_context.Bookings.Any(b => b.FKFacilitySessionId == s.FacilitySessionId))
+                .ToListAsync();
+
+            _context.FacilitySessions.RemoveRange(candidates);
+            return candidates.Count;
+        }
+
+        public async Task LinkPlanToClassAsync(Guid customerPlanId, Guid facilityClassId)
+        {
+            _context.CustomerPlanClasses.Add(new CustomerPlanClass
+            {
+                CustomerPlanClassId = Guid.NewGuid(),
+                FKCustomerPlanId = customerPlanId,
+                FKFacilityClassId = facilityClassId
+            });
+        }
+
+        public Task<List<Booking>> GetSchedulingConflictsAsync(Guid clientId)
+        {
+            return _context.Bookings
+                .Include(b => b.Facility)
+                .Where(b => b.FKClientId == clientId && b.FKFacilitySessionId == null && b.Status == "Confirmed")
+                .Where(b => _context.FacilitySessions.Any(s =>
+                    s.FKFacilityId == b.FKFacilityId && s.FKFacilityClassId != null && !s.IsCancelled &&
+                    s.StartTime < b.EndTime && s.EndTime > b.StartTime))
+                .ToListAsync();
+        }
+    }
+}

Repos/FacilityRepository.cs

@@ -41,7 +41,8 @@ namespace Fitness_core_BE.Repos
                 ?? throw new KeyNotFoundException("Facility not found");
 
             existing.Name = facility.Name;
-            existing.BookingMode = facility.BookingMode;
+            existing.SupportsClasses = facility.SupportsClasses;
+            existing.SupportsBooking = facility.SupportsBooking;
             existing.Description = facility.Description;
             existing.DefaultCapacity = facility.DefaultCapacity;
             existing.NumberOfUnits = facility.NumberOfUnits;
@@ -76,12 +77,15 @@ namespace Fitness_core_BE.Repos
                 .Include(s => s.Facility)
                 .FirstOrDefaultAsync(s => s.FacilitySessionId == facilitySessionId);
 
-        public async Task<List<FacilitySession>> GetSessions(Guid clientId, Guid? facilityId, DateTime fromUtc, DateTime toUtc)
+        public async Task<List<FacilitySession>> GetSessions(Guid clientId, Guid? facilityId, DateTime fromUtc, DateTime toUtc, bool includeCancelled = false)
         {
             var query = _context.FacilitySessions
                 .Include(s => s.Facility)
-                .Where(s => s.FKClientId == clientId && s.StartTime >= fromUtc && s.StartTime <= toUtc && !s.IsCancelled);
+                .Include(s => s.FacilityClass)
+                .Where(s => s.FKClientId == clientId && s.StartTime >= fromUtc && s.StartTime <= toUtc);
 
+            if (!includeCancelled)
+                query = query.Where(s => !s.IsCancelled);
             if (facilityId.HasValue)
                 query = query.Where(s => s.FKFacilityId == facilityId.Value);
 
@@ -91,13 +95,24 @@ namespace Fitness_core_BE.Repos
         public Task<int> GetActiveBookingCount(Guid facilitySessionId)
             => _context.Bookings.CountAsync(b => b.FKFacilitySessionId == facilitySessionId && b.Status != "Cancelled");
 
-        public async Task<FacilitySession?> CancelFacilitySession(Guid facilitySessionId, Guid clientId)
+        /// <summary>True interval overlap (StartTime &lt; end &amp;&amp; EndTime &gt; start), not a
+        /// "StartTime falls inside the window" filter like GetSessions -- a class that started
+        /// before the window and is still running must still count as occupying it.</summary>
+        public Task<List<FacilitySession>> GetOverlappingActiveSessionsAsync(Guid facilityId, DateTime startUtc, DateTime endUtc)
+            => _context.FacilitySessions
+                .Where(s => s.FKFacilityId == facilityId && !s.IsCancelled && s.StartTime < endUtc && s.EndTime > startUtc)
+                .ToListAsync();
+
+        public async Task<FacilitySession?> MarkFacilitySessionNotHeldAsync(Guid facilitySessionId, Guid clientId, string? reason)
         {
             var session = await _context.FacilitySessions
+                .Include(s => s.Bookings)
                 .FirstOrDefaultAsync(s => s.FacilitySessionId == facilitySessionId && s.FKClientId == clientId);
             if (session == null) return null;
 
             session.IsCancelled = true;
+            session.NotHeldReason = reason;
+            session.NotHeldAt = DateTime.UtcNow;
             return session;
         }
 
@@ -188,13 +203,13 @@ namespace Fitness_core_BE.Repos
                 .ToDictionary(g => g.Key, g => g.Select(pf => pf.FKFacilityId).ToList());
         }
 
-        // --- AdHoc booking support (new) ---
+        // --- WalkIn booking support (new) ---
 
-        public Task<int> GetOverlappingAdhocBookingCountAsync(Guid facilityId, DateTime startTime, DateTime endTime, Guid? excludeBookingId = null)
+        public Task<int> GetOverlappingWalkInBookingCountAsync(Guid facilityId, DateTime startTime, DateTime endTime, Guid? excludeBookingId = null)
         {
             var query = _context.Bookings.Where(b =>
                 b.FKFacilityId == facilityId &&
-                b.FKFacilitySessionId == null && // AdHoc bookings only
+                b.FKFacilitySessionId == null && // WalkIn bookings only
                 b.Status != "Cancelled" && b.Status != "NoShow" && b.Status != "Completed" &&
                 b.StartTime < endTime && b.EndTime > startTime);
 

Repos/InventoryRepository.cs

@@ -0,0 +1,188 @@
+using Fitness_core_BE.Interfaces;
+using Fitness_core_BE.Models;
+using Microsoft.EntityFrameworkCore;
+
+namespace Fitness_core_BE.Repos
+{
+    public class InventoryRepository : IInventoryRepository
+    {
+        private readonly TenantDbContext _context;
+
+        public InventoryRepository(TenantDbContext context)
+        {
+            _context = context;
+        }
+
+        // --- Products ---
+
+        public async Task<List<Product>> GetProducts(Guid clientId, bool includeInactive = false)
+        {
+            var query = _context.Products.Where(p => p.FKClientId == clientId);
+            if (!includeInactive)
+                query = query.Where(p => p.IsActive);
+
+            return await query.OrderBy(p => p.Name).ToListAsync();
+        }
+
+        public Task<Product?> GetProductById(Guid productId)
+            => _context.Products.FirstOrDefaultAsync(p => p.ProductId == productId);
+
+        public async Task<Product> CreateProduct(Product product)
+        {
+            product.ProductId = Guid.NewGuid();
+            product.CreatedAt = DateTime.UtcNow;
+            product.IsActive = true;
+            product.CostPrice = 0m;
+            product.QuantityOnHand = 0m;
+
+            _context.Products.Add(product);
+            return product;
+        }
+
+        public async Task<Product> UpdateProduct(Product product)
+        {
+            var existing = await _context.Products.FindAsync(product.ProductId)
+                ?? throw new KeyNotFoundException("Product not found");
+
+            // Sku is system-generated at creation and never edited -- not copied here.
+            existing.Name = product.Name;
+            existing.UnitOfMeasure = product.UnitOfMeasure;
+            existing.SellingPrice = product.SellingPrice;
+            existing.IsActive = product.IsActive;
+
+            return existing;
+        }
+
+        public async Task<int> GetNextProductSequence(Guid clientId)
+            => await _context.Products.CountAsync(p => p.FKClientId == clientId) + 1;
+
+        public Task<List<GoodsReceivedNoteItem>> GetGrnItemsForProduct(Guid productId)
+            => _context.GoodsReceivedNoteItems
+                .Include(i => i.Grn)
+                .Where(i => i.FKProductId == productId)
+                .OrderByDescending(i => i.Grn!.ReceivedAt)
+                .ToListAsync();
+
+        public Task<List<SaleItem>> GetSaleItemsForProduct(Guid productId)
+            => _context.SaleItems
+                .Include(i => i.Sale)
+                .Where(i => i.FKProductId == productId)
+                .OrderByDescending(i => i.Sale!.SoldAt)
+                .ToListAsync();
+
+        public Task<List<StockReturn>> GetStockReturnsForProduct(Guid productId)
+            => _context.StockReturns
+                .Where(r => r.FKProductId == productId)
+                .OrderByDescending(r => r.ReturnedAt)
+                .ToListAsync();
+
+        // --- Suppliers ---
+
+        public async Task<List<Supplier>> GetSuppliers(Guid clientId, bool includeInactive = false)
+        {
+            var query = _context.Suppliers.Where(s => s.FKClientId == clientId);
+            if (!includeInactive)
+                query = query.Where(s => s.IsActive);
+
+            return await query.OrderBy(s => s.Name).ToListAsync();
+        }
+
+        public Task<Supplier?> GetSupplierById(Guid supplierId)
+            => _context.Suppliers.FirstOrDefaultAsync(s => s.SupplierId == supplierId);
+
+        public async Task<Supplier> CreateSupplier(Supplier supplier)
+        {
+            supplier.SupplierId = Guid.NewGuid();
+            supplier.CreatedAt = DateTime.UtcNow;
+            supplier.IsActive = true;
+
+            _context.Suppliers.Add(supplier);
+            return supplier;
+        }
+
+        // --- GRN ---
+
+        public async Task<GoodsReceivedNote> CreateGrn(GoodsReceivedNote grn)
+        {
+            grn.GrnId = Guid.NewGuid();
+            grn.CreatedAt = DateTime.UtcNow;
+            foreach (var item in grn.Items)
+                item.GrnItemId = Guid.NewGuid();
+
+            _context.GoodsReceivedNotes.Add(grn);
+            return grn;
+        }
+
+        public Task<List<GoodsReceivedNote>> GetGrns(Guid clientId)
+            => _context.GoodsReceivedNotes
+                .Include(g => g.Supplier)
+                .Include(g => g.Items).ThenInclude(i => i.Product)
+                .Where(g => g.FKClientId == clientId)
+                .OrderByDescending(g => g.ReceivedAt)
+                .ToListAsync();
+
+        public Task<GoodsReceivedNote?> GetGrnById(Guid grnId)
+            => _context.GoodsReceivedNotes
+                .Include(g => g.Supplier)
+                .Include(g => g.Items).ThenInclude(i => i.Product)
+                .FirstOrDefaultAsync(g => g.GrnId == grnId);
+
+        public async Task<int> GetNextGrnSequence(Guid clientId)
+            => await _context.GoodsReceivedNotes.CountAsync(g => g.FKClientId == clientId) + 1;
+
+        // --- Sales ---
+
+        public async Task<Sale> CreateSale(Sale sale)
+        {
+            sale.SaleId = Guid.NewGuid();
+            sale.CreatedAt = DateTime.UtcNow;
+            foreach (var item in sale.Items)
+                item.SaleItemId = Guid.NewGuid();
+
+            _context.Sales.Add(sale);
+            return sale;
+        }
+
+        public Task<List<Sale>> GetSales(Guid clientId)
+            => _context.Sales
+                .Include(s => s.Items).ThenInclude(i => i.Product)
+                .Where(s => s.FKClientId == clientId)
+                .OrderByDescending(s => s.SoldAt)
+                .ToListAsync();
+
+        public Task<Sale?> GetSaleById(Guid saleId)
+            => _context.Sales
+                .Include(s => s.Items).ThenInclude(i => i.Product)
+                .FirstOrDefaultAsync(s => s.SaleId == saleId);
+
+        public async Task<int> GetNextSaleSequence(Guid clientId)
+            => await _context.Sales.CountAsync(s => s.FKClientId == clientId) + 1;
+
+        // --- Returns ---
+
+        public async Task<StockReturn> CreateStockReturn(StockReturn stockReturn)
+        {
+            stockReturn.StockReturnId = Guid.NewGuid();
+            stockReturn.CreatedAt = DateTime.UtcNow;
+
+            _context.StockReturns.Add(stockReturn);
+            return stockReturn;
+        }
+
+        public Task<List<StockReturn>> GetStockReturns(Guid clientId)
+            => _context.StockReturns
+                .Include(r => r.Product)
+                .Include(r => r.Sale)
+                .Include(r => r.Grn)
+                .Where(r => r.FKClientId == clientId)
+                .OrderByDescending(r => r.ReturnedAt)
+                .ToListAsync();
+
+        public Task<StockReturn?> GetStockReturnById(Guid stockReturnId)
+            => _context.StockReturns
+                .Include(r => r.Product)
+                .Include(r => r.Sale)
+                .Include(r => r.Grn)
+                .FirstOrDefaultAsync(r => r.StockReturnId == stockReturnId);
+    }
+}

Repos/ProfitLossRepository.cs

@@ -105,9 +105,68 @@ namespace Fitness_core_BE.Repos
                 })
                 .ToListAsync(ct);
 
+            // Inventory: a Sale's revenue, a GRN's cost, and a StockReturn's Amount (staff-
+            // entered -- see StockReturn's doc comment). Every return Category still posts the
+            // same way here (one Expense category, reducing profit) even though CustomerReturn
+            // is the one category that adds the stock back -- the P&L side stays uniform while
+            // the stock-direction side doesn't.
+            var productSales = await _context.Sales
+                .AsNoTracking()
+                .Where(sale =>
+                    sale.FKClientId == clientId &&
+                    sale.SoldAt >= fromUtc &&
+                    sale.SoldAt < toUtc)
+                .Select(sale => new LedgerEntryDto
+                {
+                    EntryType = "Income",
+                    Category = "Product Sales",
+                    Description = sale.SaleNumber,
+                    Amount = sale.TotalAmount,
+                    EntryDate = sale.SoldAt,
+                    IsManual = false
+                })
+                .ToListAsync(ct);
+
+            var inventoryPurchases = await _context.GoodsReceivedNotes
+                .AsNoTracking()
+                .Where(grn =>
+                    grn.FKClientId == clientId &&
+                    grn.ReceivedAt >= fromUtc &&
+                    grn.ReceivedAt < toUtc)
+                .Select(grn => new LedgerEntryDto
+                {
+                    EntryType = "Expense",
+                    Category = "Inventory Purchases",
+                    Description = grn.GrnNumber,
+                    Amount = grn.TotalAmount,
+                    EntryDate = grn.ReceivedAt,
+                    IsManual = false
+                })
+                .ToListAsync(ct);
+
+            var inventoryWriteOffs = await _context.StockReturns
+                .AsNoTracking()
+                .Where(stockReturn =>
+                    stockReturn.FKClientId == clientId &&
+                    stockReturn.ReturnedAt >= fromUtc &&
+                    stockReturn.ReturnedAt < toUtc)
+                .Select(stockReturn => new LedgerEntryDto
+                {
+                    EntryType = "Expense",
+                    Category = "Inventory Write-offs",
+                    Description = stockReturn.Category + " — " + stockReturn.Product!.Name,
+                    Amount = stockReturn.Amount,
+                    EntryDate = stockReturn.ReturnedAt,
+                    IsManual = false
+                })
+                .ToListAsync(ct);
+
             memberPayments.AddRange(platformInvoices);
             memberPayments.AddRange(staffPayments);
             memberPayments.AddRange(bookingPayments);
+            memberPayments.AddRange(productSales);
+            memberPayments.AddRange(inventoryPurchases);
+            memberPayments.AddRange(inventoryWriteOffs);
             return memberPayments;
         }
 

Services/BookingService.cs

@@ -50,8 +50,14 @@ namespace Fitness_core_BE.Services
                 if (await _bookingRepository.CustomerHasActiveBookingForSession(facilitySessionId, cusId))
                     throw new ArgumentException("You already have a booking for this session");
 
-                var subscription = await _customerSubscriptionRepository.GetActiveSubscriptionByCustomerId(cusId)
-                    ?? throw new ArgumentException("No active membership plan found");
+                // A class occurrence (FKFacilityClassId set) must be covered by a subscription
+                // linked to that specific class; a legacy/manually-created session (null) falls
+                // back to the customer's gym-access subscription, same as before Classes existed.
+                var subscription = session.FKFacilityClassId.HasValue
+                    ? await _customerSubscriptionRepository.GetActiveSubscriptionForClassAsync(cusId, session.FKFacilityClassId.Value)
+                        ?? throw new ArgumentException("Your membership doesn't cover this class.")
+                    : await _customerSubscriptionRepository.GetActiveGymAccessSubscriptionAsync(cusId)
+                        ?? throw new ArgumentException("No active membership plan found");
 
                 // Null SessionsPerCycle = unlimited-access plan (existing gym behavior) --
                 // no allowance to check. A set value caps how many Facility sessions this
@@ -70,10 +76,13 @@ namespace Fitness_core_BE.Services
                         throw new ArgumentException("You've used all the sessions included in your current plan cycle");
                 }
 
-                var capacity = session.Capacity ?? session.Facility?.DefaultCapacity ?? 1;
-                var bookedCount = await _facilityRepository.GetActiveBookingCount(facilitySessionId);
-                if (bookedCount >= capacity)
-                    throw new ArgumentException("This session is fully booked");
+                if (!session.IsUnlimitedCapacity)
+                {
+                    var capacity = session.Capacity ?? session.Facility?.DefaultCapacity ?? 1;
+                    var bookedCount = await _facilityRepository.GetActiveBookingCount(facilitySessionId);
+                    if (bookedCount >= capacity)
+                        throw new ArgumentException("This session is fully booked");
+                }
 
                 var booking = new Booking
                 {
@@ -124,10 +133,13 @@ namespace Fitness_core_BE.Services
                 if (session.StartTime <= DateTime.UtcNow)
                     throw new ArgumentException("This session has already started");
 
-                var capacity = session.Capacity ?? session.Facility?.DefaultCapacity ?? 1;
-                var bookedCount = await _facilityRepository.GetActiveBookingCount(facilitySessionId);
-                if (bookedCount >= capacity)
-                    throw new ArgumentException("This session is fully booked");
+                if (!session.IsUnlimitedCapacity)
+                {
+                    var capacity = session.Capacity ?? session.Facility?.DefaultCapacity ?? 1;
+                    var bookedCount = await _facilityRepository.GetActiveBookingCount(facilitySessionId);
+                    if (bookedCount >= capacity)
+                        throw new ArgumentException("This session is fully booked");
+                }
 
                 var booking = new Booking
                 {
@@ -161,14 +173,14 @@ namespace Fitness_core_BE.Services
             }
         }
 
-        // ---------- AdHoc-mode creation (new) ----------
+        // ---------- WalkIn-mode creation (new) ----------
 
-        public async Task<object> CreateMemberAdhocBooking(object payload, HttpContext httpContext)
+        public async Task<object> CreateMemberWalkInBooking(object payload, HttpContext httpContext)
         {
             await _uow.BeginAsync();
             try
             {
-                var (facility, startTime, endTime, partySize, _) = await ValidateAdhocRequestAsync(payload);
+                var (facility, startTime, endTime, partySize, _) = await ValidateWalkInRequestAsync(payload);
 
                 var cusId = await _userRoleHelper.GetCusId(DataExtractor.GetUserIdFromContext(httpContext));
 
@@ -201,12 +213,12 @@ namespace Fitness_core_BE.Services
             }
         }
 
-        public async Task<object> CreateGuestAdhocBooking(object payload, HttpContext httpContext)
+        public async Task<object> CreateGuestWalkInBooking(object payload, HttpContext httpContext)
         {
             await _uow.BeginAsync();
             try
             {
-                var (facility, startTime, endTime, partySize, pricePerHour) = await ValidateAdhocRequestAsync(payload);
+                var (facility, startTime, endTime, partySize, pricePerHour) = await ValidateWalkInRequestAsync(payload);
 
                 var data = DeserializePayload.Deserialize(payload);
                 var guestName = data["guestName"].GetString() ?? throw new ArgumentException("guestName is required");
@@ -249,11 +261,11 @@ namespace Fitness_core_BE.Services
             }
         }
 
-        /// <summary>Shared validation for both AdHoc creation paths: facility must be AdHoc-mode,
-        /// requested window must have a free unit. Locks the facility row for the duration of the
-        /// caller's transaction so two concurrent claims on the same facility serialize instead of
-        /// both reading "room available" before either commits.</summary>
-        private async Task<(Facility facility, DateTime startTime, DateTime endTime, int? partySize, decimal? pricePerHour)> ValidateAdhocRequestAsync(object payload)
+        /// <summary>Shared validation for both WalkIn creation paths: facility must support
+        /// walk-in booking, requested window must have a free unit. Locks the facility row for
+        /// the duration of the caller's transaction so two concurrent claims on the same facility
+        /// serialize instead of both reading "room available" before either commits.</summary>
+        private async Task<(Facility facility, DateTime startTime, DateTime endTime, int? partySize, decimal? pricePerHour)> ValidateWalkInRequestAsync(object payload)
         {
             var data = DeserializePayload.Deserialize(payload);
             var facilityId = Guid.Parse(data["facilityId"].GetString()!);
@@ -276,13 +288,20 @@ namespace Fitness_core_BE.Services
 
             var facility = await _facilityRepository.GetFacilityById(facilityId)
                 ?? throw new KeyNotFoundException("Facility not found");
-            if (facility.BookingMode != "AdHoc")
-                throw new ArgumentException("This facility does not support ad-hoc booking");
+            if (!facility.SupportsBooking)
+                throw new ArgumentException("This facility does not support walk-in booking");
             if (!facility.IsActive)
                 throw new ArgumentException("This facility is not active");
 
             await _facilityRepository.LockFacilityForUpdateAsync(facilityId);
-            var overlapping = await _facilityRepository.GetOverlappingAdhocBookingCountAsync(facilityId, startTime, endTime);
+
+            // A running class occupies the whole facility, not just a seat -- reject the walk-in
+            // request outright rather than letting it compete for units.
+            var overlappingSessions = await _facilityRepository.GetOverlappingActiveSessionsAsync(facilityId, startTime, endTime);
+            if (overlappingSessions.Count > 0)
+                throw new ArgumentException("This facility is occupied by a scheduled class during the requested time");
+
+            var overlapping = await _facilityRepository.GetOverlappingWalkInBookingCountAsync(facilityId, startTime, endTime);
             if (overlapping >= facility.NumberOfUnits)
                 throw new ArgumentException("No units are free for the requested time");
 
@@ -291,7 +310,7 @@ namespace Fitness_core_BE.Services
 
         /// <summary>Staff can optionally identify a walk-in guest as an already-registered member
         /// (search-and-pick, not free-typed) -- purely for identification/auto-fill on the FE, see
-        /// CreateGuestBooking/CreateGuestAdhocBooking. Doesn't change IsGuest, PaymentStatus, or
+        /// CreateGuestBooking/CreateGuestWalkInBooking. Doesn't change IsGuest, PaymentStatus, or
         /// any membership handling; FKCustomerId is just an informational link layered on top of
         /// an otherwise-ordinary guest booking.</summary>
         private async Task<Guid?> ResolveOptionalCustomerLinkAsync(Dictionary<string, JsonElement> data)
@@ -448,18 +467,7 @@ namespace Fitness_core_BE.Services
                 if (booking.Status == "CheckedIn")
                     throw new ArgumentException("This booking has already been checked in and can't be cancelled");
 
-                booking.Status = "Cancelled";
-
-                // Give the session allowance back -- only member bookings draw one down.
-                if (!booking.IsGuest && booking.FKCustomerSubscriptionId.HasValue)
-                {
-                    var subscription = await _customerSubscriptionRepository.GetActiveSubscriptionByCustomerId(booking.FKCustomerId!.Value);
-                    if (subscription != null && subscription.SubscriptionId == booking.FKCustomerSubscriptionId.Value
-                        && subscription.CustomerPlan.SessionsPerCycle.HasValue && subscription.SessionsUsedThisCycle > 0)
-                    {
-                        subscription.SessionsUsedThisCycle--;
-                    }
-                }
+                await CancelBookingCore(booking);
 
                 await _uow.CommitAsync();
                 return MapToDto(booking, includeOtp: false);
@@ -471,6 +479,29 @@ namespace Fitness_core_BE.Services
             }
         }
 
+        /// <summary>Just the in-memory mutations (status + subscription allowance refund), no
+        /// transaction demarcation or status validation -- called both by CancelBooking (after
+        /// its own status checks) and by FacilityService's "mark not held" cascade (which does
+        /// its own per-booking filtering before calling this for each affected booking), so
+        /// there's one refund code path instead of two. Looks the subscription up by the exact
+        /// id the booking drew its allowance from, rather than re-resolving "the customer's
+        /// current active subscription" -- correct regardless of which kind of subscription
+        /// (gym-access or class-linked) it was, and unaffected by the customer holding others.</summary>
+        public async Task CancelBookingCore(Booking booking)
+        {
+            booking.Status = "Cancelled";
+
+            // Give the session allowance back -- only member bookings draw one down.
+            if (!booking.IsGuest && booking.FKCustomerSubscriptionId.HasValue)
+            {
+                var subscription = await _customerSubscriptionRepository.GetCustomerSubscriptionById(booking.FKCustomerSubscriptionId.Value);
+                if (subscription != null && subscription.CustomerPlan.SessionsPerCycle.HasValue && subscription.SessionsUsedThisCycle > 0)
+                {
+                    subscription.SessionsUsedThisCycle--;
+                }
+            }
+        }
+
         public async Task<object> ReassignBooking(object payload, HttpContext httpContext)
         {
             await _uow.BeginAsync();
@@ -514,9 +545,9 @@ namespace Fitness_core_BE.Services
 
                 if (booking.FKFacilitySessionId == null)
                 {
-                    // AdHoc: move to a new time on the same facility.
+                    // WalkIn: move to a new time on the same facility.
                     if (!data.ContainsKey("startTime") || !data.ContainsKey("durationMinutes"))
-                        throw new ArgumentException("startTime and durationMinutes are required to reschedule an ad-hoc booking");
+                        throw new ArgumentException("startTime and durationMinutes are required to reschedule a walk-in booking");
 
                     var startTime = DateTime.Parse(data["startTime"].GetString()!).ToUniversalTime();
                     var durationMinutes = data["durationMinutes"].GetInt32();
@@ -524,7 +555,15 @@ namespace Fitness_core_BE.Services
                     var endTime = startTime.AddMinutes(durationMinutes);
 
                     await _facilityRepository.LockFacilityForUpdateAsync(booking.FKFacilityId);
-                    var overlapping = await _facilityRepository.GetOverlappingAdhocBookingCountAsync(
+
+                    // Same class-occupancy guard as a fresh walk-in request -- otherwise staff
+                    // could reschedule straight into a scheduled class's time.
+                    var overlappingSessions = await _facilityRepository.GetOverlappingActiveSessionsAsync(
+                        booking.FKFacilityId, startTime, endTime);
+                    if (overlappingSessions.Count > 0)
+                        throw new ArgumentException("This facility is occupied by a scheduled class during the requested time");
+
+                    var overlapping = await _facilityRepository.GetOverlappingWalkInBookingCountAsync(
                         booking.FKFacilityId, startTime, endTime, excludeBookingId: booking.BookingId);
 
                     var facility = booking.Facility ?? await _facilityRepository.GetFacilityById(booking.FKFacilityId)
@@ -777,7 +816,9 @@ namespace Fitness_core_BE.Services
             FacilitySessionId = booking.FKFacilitySessionId,
             FacilityId = booking.FKFacilityId,
             FacilityName = booking.Facility?.Name,
-            BookingMode = booking.Facility?.BookingMode ?? (booking.FKFacilitySessionId.HasValue ? "Scheduled" : "AdHoc"),
+            // Per-booking fact (which path created it) -- a facility can support both modes now,
+            // so this no longer derives from the facility at all.
+            BookingMode = booking.FKFacilitySessionId.HasValue ? "Scheduled" : "WalkIn",
             StartTime = booking.StartTime,
             EndTime = booking.EndTime,
             PartySize = booking.PartySize,

Services/ClassService.cs

@@ -0,0 +1,388 @@
+using Fitness_core_BE.DTOs.Facility;
+using Fitness_core_BE.Helpers;
+using Fitness_core_BE.Infra.UoW;
+using Fitness_core_BE.Interfaces;
+using Fitness_core_BE.Interfaces.Services;
+using Fitness_core_BE.Models;
+using Microsoft.EntityFrameworkCore;
+using System.Text.Json;
+
+namespace Fitness_core_BE.Services
+{
+    public class ClassService : IClassService
+    {
+        private static readonly string[] ValidRecurrenceTypes = ["Daily", "Weekly", "Monthly", "Custom"];
+        private const int GenerationHorizonDays = 56; // 8 weeks
+
+        private readonly IFacilityClassRepository _classRepository;
+        private readonly IFacilityRepository _facilityRepository;
+        private readonly IUnitOfWork _uow;
+        private readonly UserRoleHelper _userRoleHelper;
+
+        public ClassService(
+            IFacilityClassRepository classRepository,
+            IFacilityRepository facilityRepository,
+            IUnitOfWork uow,
+            UserRoleHelper userRoleHelper)
+        {
+            _classRepository = classRepository;
+            _facilityRepository = facilityRepository;
+            _uow = uow;
+            _userRoleHelper = userRoleHelper;
+        }
+
+        public async Task<object> GetFacilityClasses(object payload, HttpContext httpContext)
+        {
+            var data = DeserializePayload.Deserialize(payload);
+            bool includeInactive = data.ContainsKey("includeInactive") && data["includeInactive"].GetBoolean();
+
+            var clientId = await _userRoleHelper.GetClientId(DataExtractor.GetUserIdFromContext(httpContext));
+            var classes = await _classRepository.GetFacilityClasses(clientId, includeInactive);
+
+            return classes.Select(MapToDto).ToList();
+        }
+
+        public async Task<object> CreateFacilityClass(object payload, HttpContext httpContext)
+        {
+            await _uow.BeginAsync();
+            try
+            {
+                var data = DeserializePayload.Deserialize(payload);
+                var clientId = await _userRoleHelper.GetClientId(DataExtractor.GetUserIdFromContext(httpContext));
+
+                var facilityId = Guid.Parse(data["facilityId"].GetString()!);
+                var facility = await _facilityRepository.GetFacilityById(facilityId);
+                if (facility == null || facility.FKClientId != clientId)
+                    throw new KeyNotFoundException("Facility not found");
+                if (!facility.SupportsClasses)
+                    throw new ArgumentException("This facility does not support classes");
+
+                if (!data.ContainsKey("name")) throw new KeyNotFoundException("name is required");
+
+                var recurrenceType = data.ContainsKey("recurrenceType") ? data["recurrenceType"].GetString() ?? "Weekly" : "Weekly";
+                if (!ValidRecurrenceTypes.Contains(recurrenceType))
+                    throw new ArgumentException($"recurrenceType must be one of: {string.Join(", ", ValidRecurrenceTypes)}");
+
+                var isUnlimitedCapacity = data.ContainsKey("isUnlimitedCapacity") && data["isUnlimitedCapacity"].GetBoolean();
+                int? capacity = data.ContainsKey("capacity") && data["capacity"].ValueKind != JsonValueKind.Null
+                    ? data["capacity"].GetInt32() : null;
+                if (!isUnlimitedCapacity && capacity.HasValue && capacity.Value < 1)
+                    throw new ArgumentException("capacity must be at least 1 when set");
+
+                var durationMinutes = data.ContainsKey("durationMinutes") ? data["durationMinutes"].GetInt32() : 60;
+                if (durationMinutes < 1) throw new ArgumentException("durationMinutes must be at least 1");
+
+                var facilityClass = new FacilityClass
+                {
+                    FKClientId = clientId,
+                    FKFacilityId = facilityId,
+                    Name = data["name"].GetString() ?? "",
+                    Description = data.ContainsKey("description") ? data["description"].GetString() : null,
+                    RecurrenceType = recurrenceType,
+                    DurationMinutes = durationMinutes,
+                    Capacity = isUnlimitedCapacity ? null : capacity,
+                    IsUnlimitedCapacity = isUnlimitedCapacity
+                };
+
+                if (recurrenceType == "Custom")
+                {
+                    // Occurrences are explicit -- no rule fields, no generation watermark ever
+                    // consulted for this class.
+                    facilityClass.OccurrencesGeneratedThrough = DateTime.UtcNow.Date;
+                    var result = await _classRepository.CreateFacilityClass(facilityClass);
+                    await _uow.SaveChangesAsync(); // persist the id before occurrences reference it
+
+                    await AddCustomOccurrencesAsync(facilityClass, data);
+
+                    await _uow.CommitAsync();
+                    result.Facility = facility;
+                    return MapToDto(result);
+                }
+                else
+                {
+                    if (!data.ContainsKey("startTimeOfDay")) throw new KeyNotFoundException("startTimeOfDay is required");
+                    facilityClass.StartTimeOfDay = TimeSpan.Parse(data["startTimeOfDay"].GetString()!);
+                    facilityClass.WeekDaysMask = data.ContainsKey("weekDaysMask") ? data["weekDaysMask"].GetInt32() : 0;
+                    facilityClass.MonthDays = data.ContainsKey("monthDays") ? data["monthDays"].GetString() : null;
+                    facilityClass.SeriesStartDate = data.ContainsKey("seriesStartDate") && data["seriesStartDate"].ValueKind != JsonValueKind.Null
+                        ? DateTime.Parse(data["seriesStartDate"].GetString()!).Date
+                        : DateTime.UtcNow.Date;
+                    facilityClass.SeriesEndDate = data.ContainsKey("seriesEndDate") && data["seriesEndDate"].ValueKind != JsonValueKind.Null
+                        ? DateTime.Parse(data["seriesEndDate"].GetString()!).Date
+                        : null;
+
+                    if (recurrenceType == "Weekly" && facilityClass.WeekDaysMask == 0)
+                        throw new ArgumentException("Select at least one day of the week");
+                    if (recurrenceType == "Monthly" && string.IsNullOrWhiteSpace(facilityClass.MonthDays))
+                        throw new ArgumentException("Select at least one day of the month");
+
+                    // Nothing generated yet -- the next GetSessions call does it lazily.
+                    facilityClass.OccurrencesGeneratedThrough = facilityClass.SeriesStartDate.AddDays(-1);
+
+                    var result = await _classRepository.CreateFacilityClass(facilityClass);
+                    await _uow.CommitAsync();
+                    result.Facility = facility;
+                    return MapToDto(result);
+                }
+            }
+            catch
+            {
+                await _uow.RollbackAsync();
+                throw;
+            }
+        }
+
+        public async Task<object> UpdateFacilityClass(object payload, HttpContext httpContext)
+        {
+            await _uow.BeginAsync();
+            try
+            {
+                var data = DeserializePayload.Deserialize(payload);
+                var facilityClassId = Guid.Parse(data["facilityClassId"].GetString()!);
+
+                var existing = await _classRepository.GetFacilityClassById(facilityClassId)
+                    ?? throw new KeyNotFoundException("Class not found");
+
+                if (data.ContainsKey("name")) existing.Name = data["name"].GetString() ?? existing.Name;
+                if (data.ContainsKey("description")) existing.Description = data["description"].GetString();
+                if (data.ContainsKey("isActive")) existing.IsActive = data["isActive"].GetBoolean();
+
+                if (data.ContainsKey("isUnlimitedCapacity")) existing.IsUnlimitedCapacity = data["isUnlimitedCapacity"].GetBoolean();
+                if (data.ContainsKey("capacity"))
+                {
+                    var capacity = data["capacity"].ValueKind != JsonValueKind.Null ? data["capacity"].GetInt32() : (int?)null;
+                    if (!existing.IsUnlimitedCapacity && capacity.HasValue && capacity.Value < 1)
+                        throw new ArgumentException("capacity must be at least 1 when set");
+                    existing.Capacity = existing.IsUnlimitedCapacity ? null : capacity;
+                }
+
+                // Only these recurrence-rule fields trigger a regeneration -- editing the name,
+                // description, capacity or active flag doesn't touch existing occurrences.
+                var recurrenceKeys = new[] { "recurrenceType", "startTimeOfDay", "durationMinutes", "weekDaysMask", "monthDays", "seriesStartDate", "seriesEndDate" };
+                var recurrenceChanged = recurrenceKeys.Any(data.ContainsKey);
+
+                if (recurrenceChanged && existing.RecurrenceType != "Custom")
+                {
+                    if (data.ContainsKey("recurrenceType"))
+                    {
+                        var recurrenceType = data["recurrenceType"].GetString() ?? existing.RecurrenceType;
+                        if (!ValidRecurrenceTypes.Contains(recurrenceType))
+                            throw new ArgumentException($"recurrenceType must be one of: {string.Join(", ", ValidRecurrenceTypes)}");
+                        existing.RecurrenceType = recurrenceType;
+                    }
+                    if (data.ContainsKey("startTimeOfDay")) existing.StartTimeOfDay = TimeSpan.Parse(data["startTimeOfDay"].GetString()!);
+                    if (data.ContainsKey("durationMinutes"))
+                    {
+                        var durationMinutes = data["durationMinutes"].GetInt32();
+                        if (durationMinutes < 1) throw new ArgumentException("durationMinutes must be at least 1");
+                        existing.DurationMinutes = durationMinutes;
+                    }
+                    if (data.ContainsKey("weekDaysMask")) existing.WeekDaysMask = data["weekDaysMask"].GetInt32();
+                    if (data.ContainsKey("monthDays")) existing.MonthDays = data["monthDays"].GetString();
+                    if (data.ContainsKey("seriesStartDate") && data["seriesStartDate"].ValueKind != JsonValueKind.Null)
+                        existing.SeriesStartDate = DateTime.Parse(data["seriesStartDate"].GetString()!).Date;
+                    if (data.ContainsKey("seriesEndDate"))
+                        existing.SeriesEndDate = data["seriesEndDate"].ValueKind != JsonValueKind.Null
+                            ? DateTime.Parse(data["seriesEndDate"].GetString()!).Date : null;
+
+                    if (existing.RecurrenceType == "Weekly" && existing.WeekDaysMask == 0)
+                        throw new ArgumentException("Select at least one day of the week");
+                    if (existing.RecurrenceType == "Monthly" && string.IsNullOrWhiteSpace(existing.MonthDays))
+                        throw new ArgumentException("Select at least one day of the month");
+
+                    // Anything past or already booked is left alone -- only future, unbooked
+                    // occurrences are cleared so the next read regenerates them under the new rule.
+                    await _classRepository.DeleteFutureUnbookedOccurrencesAsync(existing.FacilityClassId, DateTime.UtcNow);
+                    existing.OccurrencesGeneratedThrough = existing.SeriesStartDate > DateTime.UtcNow.Date
+                        ? existing.SeriesStartDate.AddDays(-1)
+                        : DateTime.UtcNow.Date.AddDays(-1);
+                }
+                else if (existing.RecurrenceType == "Custom" && data.ContainsKey("addCustomOccurrences"))
+                {
+                    await AddCustomOccurrencesAsync(existing, data, "addCustomOccurrences");
+                }
+
+                var result = await _classRepository.UpdateFacilityClass(existing);
+                await _uow.CommitAsync();
+                return MapToDto(result);
+            }
+            catch
+            {
+                await _uow.RollbackAsync();
+                throw;
+            }
+        }
+
+        public async Task<object> GetOccurrences(object payload, HttpContext httpContext)
+        {
+            var data = DeserializePayload.Deserialize(payload);
+            var facilityClassId = Guid.Parse(data["facilityClassId"].GetString()!);
+            bool includeCancelled = data.ContainsKey("includeCancelled") && data["includeCancelled"].GetBoolean();
+
+            var clientId = await _userRoleHelper.GetClientId(DataExtractor.GetUserIdFromContext(httpContext));
+            var facilityClass = await _classRepository.GetFacilityClassById(facilityClassId);
+            if (facilityClass == null || facilityClass.FKClientId != clientId)
+                throw new KeyNotFoundException("Class not found");
+
+            var occurrences = await _classRepository.GetOccurrencesForClassAsync(facilityClassId, includeCancelled);
+            return occurrences.Select(o => new
+            {
+                facilitySessionId = o.FacilitySessionId,
+                startTime = o.StartTime,
+                endTime = o.EndTime,
+                capacity = o.Capacity,
+                isUnlimitedCapacity = o.IsUnlimitedCapacity,
+                isCancelled = o.IsCancelled,
+                notHeldReason = o.NotHeldReason,
+                notHeldAt = o.NotHeldAt
+            }).ToList();
+        }
+
+        public async Task<object> GetSchedulingConflicts(object payload, HttpContext httpContext)
+        {
+            var clientId = await _userRoleHelper.GetClientId(DataExtractor.GetUserIdFromContext(httpContext));
+            var conflicts = await _classRepository.GetSchedulingConflictsAsync(clientId);
+
+            return conflicts.Select(b => new SchedulingConflictDto
+            {
+                BookingId = b.BookingId,
+                FacilityId = b.FKFacilityId,
+                FacilityName = b.Facility?.Name,
+                GuestName = b.IsGuest ? b.GuestName : null,
+                StartTime = b.StartTime,
+                EndTime = b.EndTime
+            }).ToList();
+        }
+
+        public async Task EnsureOccurrencesGeneratedAsync(Guid clientId)
+        {
+            var horizon = DateTime.UtcNow.Date.AddDays(GenerationHorizonDays);
+            var classes = await _classRepository.GetClassesNeedingGenerationAsync(clientId, horizon);
+            if (classes.Count == 0) return;
+
+            await _uow.BeginAsync();
+            try
+            {
+                foreach (var facilityClass in classes)
+                    await GenerateOccurrencesForClassAsync(facilityClass, horizon);
+
+                await _uow.CommitAsync();
+            }
+            catch (DbUpdateException)
+            {
+                // Two concurrent calendar loads raced to generate the same occurrence -- the
+                // unique (FKFacilityClassId, StartTime) index caught it. Roll back this whole
+                // batch rather than partially applying it; the next read regenerates safely
+                // (watermarks simply won't have advanced this one time).
+                await _uow.RollbackAsync();
+            }
+        }
+
+        private async Task GenerateOccurrencesForClassAsync(FacilityClass facilityClass, DateTime horizon)
+        {
+            var genFrom = facilityClass.OccurrencesGeneratedThrough > facilityClass.SeriesStartDate
+                ? facilityClass.OccurrencesGeneratedThrough.AddDays(1)
+                : facilityClass.SeriesStartDate;
+            var genTo = facilityClass.SeriesEndDate.HasValue && facilityClass.SeriesEndDate.Value < horizon
+                ? facilityClass.SeriesEndDate.Value
+                : horizon;
+
+            if (genFrom > genTo)
+            {
+                facilityClass.OccurrencesGeneratedThrough = horizon;
+                return;
+            }
+
+            var existingStartTimes = await _classRepository.GetExistingOccurrenceStartTimesAsync(
+                facilityClass.FacilityClassId,
+                LocalToUtc(genFrom),
+                LocalToUtc(genTo.AddDays(1)));
+
+            var monthDays = !string.IsNullOrWhiteSpace(facilityClass.MonthDays)
+                ? facilityClass.MonthDays.Split(',').Select(d => int.Parse(d.Trim())).ToHashSet()
+                : new HashSet<int>();
+
+            var toAdd = new List<FacilitySession>();
+            for (var date = genFrom.Date; date <= genTo.Date; date = date.AddDays(1))
+            {
+                bool runsToday = facilityClass.RecurrenceType switch
+                {
+                    "Daily" => true,
+                    "Weekly" => (facilityClass.WeekDaysMask & (1 << (int)date.DayOfWeek)) != 0,
+                    "Monthly" => monthDays.Contains(date.Day),
+                    _ => false
+                };
+                if (!runsToday) continue;
+
+                var utcStart = LocalToUtc(date.Date + facilityClass.StartTimeOfDay);
+                if (existingStartTimes.Contains(utcStart)) continue;
+
+                toAdd.Add(new FacilitySession
+                {
+                    FKFacilityId = facilityClass.FKFacilityId,
+                    FKClientId = facilityClass.FKClientId,
+                    StartTime = utcStart,
+                    EndTime = utcStart.AddMinutes(facilityClass.DurationMinutes),
+                    Capacity = facilityClass.Capacity,
+                    IsUnlimitedCapacity = facilityClass.IsUnlimitedCapacity,
+                    FKFacilityClassId = facilityClass.FacilityClassId
+                });
+            }
+
+            if (toAdd.Count > 0)
+                await _classRepository.AddOccurrencesAsync(toAdd);
+
+            facilityClass.OccurrencesGeneratedThrough = genTo;
+        }
+
+        private static DateTime LocalToUtc(DateTime localUnspecified)
+            => TimeZoneInfo.ConvertTimeToUtc(DateTime.SpecifyKind(localUnspecified, DateTimeKind.Unspecified), TimeZoneHelper.SriLanka);
+
+        private async Task AddCustomOccurrencesAsync(FacilityClass facilityClass, Dictionary<string, JsonElement> data, string key = "customOccurrences")
+        {
+            if (!data.ContainsKey(key) || data[key].ValueKind != JsonValueKind.Array) return;
+
+            var occurrences = new List<FacilitySession>();
+            foreach (var occEl in data[key].EnumerateArray())
+            {
+                var startTime = DateTime.Parse(occEl.GetProperty("startTime").GetString()!).ToUniversalTime();
+                var durationMinutes = occEl.GetProperty("durationMinutes").GetInt32();
+                if (durationMinutes < 1) throw new ArgumentException("durationMinutes must be at least 1");
+
+                occurrences.Add(new FacilitySession
+                {
+                    FKFacilityId = facilityClass.FKFacilityId,
+                    FKClientId = facilityClass.FKClientId,
+                    StartTime = startTime,
+                    EndTime = startTime.AddMinutes(durationMinutes),
+                    Capacity = facilityClass.Capacity,
+                    IsUnlimitedCapacity = facilityClass.IsUnlimitedCapacity,
+                    FKFacilityClassId = facilityClass.FacilityClassId
+                });
+            }
+
+            if (occurrences.Count > 0)
+                await _classRepository.AddOccurrencesAsync(occurrences);
+        }
+
+        private static FacilityClassDto MapToDto(FacilityClass fc) => new()
+        {
+            FacilityClassId = fc.FacilityClassId,
+            FacilityId = fc.FKFacilityId,
+            FacilityName = fc.Facility?.Name,
+            Name = fc.Name,
+            Description = fc.Description,
+            RecurrenceType = fc.RecurrenceType,
+            StartTimeOfDay = fc.RecurrenceType == "Custom" ? null : fc.StartTimeOfDay.ToString("hh\\:mm"),
+            DurationMinutes = fc.DurationMinutes,
+            WeekDaysMask = fc.WeekDaysMask,
+            MonthDays = fc.MonthDays,
+            SeriesStartDate = fc.SeriesStartDate,
+            SeriesEndDate = fc.SeriesEndDate,
+            Capacity = fc.Capacity,
+            IsUnlimitedCapacity = fc.IsUnlimitedCapacity,
+            IsActive = fc.IsActive,
+            CreatedAt = fc.CreatedAt
+        };
+    }
+}

Services/CustomerPlanService.cs

@@ -12,6 +12,7 @@ namespace Fitness_core_BE.Services.CustomerPlanService
     public class CustomerPlanService(
         ICustomerPlanRepository customerPlanRepository,
         IFacilityRepository facilityRepository,
+        IFacilityClassRepository facilityClassRepository,
         IUnitOfWork uow,
         UserRoleHelper userRoleHelper) : ICustomerPlanService
     {
@@ -26,6 +27,7 @@ namespace Fitness_core_BE.Services.CustomerPlanService
 
         private readonly ICustomerPlanRepository _customerPlanRepository = customerPlanRepository;
         private readonly IFacilityRepository _facilityRepository = facilityRepository;
+        private readonly IFacilityClassRepository _facilityClassRepository = facilityClassRepository;
         private readonly IUnitOfWork _uow = uow;
         private readonly UserRoleHelper _userRoleHelper = userRoleHelper;
 
@@ -101,6 +103,16 @@ namespace Fitness_core_BE.Services.CustomerPlanService
                 Guid userId = DataExtractor.GetUserIdFromContext(httpContext);
                 Guid clientId = await _userRoleHelper.GetClientId(userId);
 
+                // Only meaningful when facilityClassId is set below (the Classes tab's "Manage
+                // Plan" action) -- never consulted for an ordinary plan, which always grants gym
+                // access regardless of this stored value. Defaults to false for a class plan
+                // (the "sportsman" case: class access only) unless staff opts it on.
+                Guid? facilityClassId = data.ContainsKey("facilityClassId") && data["facilityClassId"].ValueKind != JsonValueKind.Null
+                    ? Guid.Parse(data["facilityClassId"].GetString()!) : null;
+                var grantsGymAccess = facilityClassId.HasValue
+                    ? data.ContainsKey("grantsGymAccess") && data["grantsGymAccess"].GetBoolean()
+                    : true;
+
                 var customerPlan = new Models.CustomerPlan
                 {
                     FKClientId = clientId,
@@ -124,7 +136,8 @@ namespace Fitness_core_BE.Services.CustomerPlanService
                         : null,
                     SessionRolloverPolicy = data.ContainsKey("sessionRolloverPolicy") ? data["sessionRolloverPolicy"].GetString() ?? RolloverNone : RolloverNone,
                     RolloverGraceDays = data.ContainsKey("rolloverGraceDays") ? data["rolloverGraceDays"].GetInt32() : 0,
-                    BillingTiming = data.ContainsKey("billingTiming") ? data["billingTiming"].GetString() ?? BillingPrepaid : BillingPrepaid
+                    BillingTiming = data.ContainsKey("billingTiming") ? data["billingTiming"].GetString() ?? BillingPrepaid : BillingPrepaid,
+                    GrantsGymAccess = grantsGymAccess
                 };
 
                 NormalizeAndValidate(customerPlan);
@@ -132,6 +145,9 @@ namespace Fitness_core_BE.Services.CustomerPlanService
                 var result = await _customerPlanRepository.CreateCustomerPlan(customerPlan);
                 await _uow.SaveChangesAsync();
 
+                if (facilityClassId.HasValue)
+                    await _facilityClassRepository.LinkPlanToClassAsync(result.CustomerPlanId, facilityClassId.Value);
+
                 var placeIds = DataExtractor.GetOptionalGuidList(data, "placeIds");
                 if (placeIds != null)
                     await _facilityRepository.SetPlanFacilitiesAsync(result.CustomerPlanId, placeIds);

Services/CustomerService.cs

@@ -440,13 +440,27 @@ namespace Fitness_core_BE.Services.CustomerService
                 // member is created without a plan — e.g. a group secondary added later).
                 if (data.ContainsKey("customerPlanId") && data["customerPlanId"].ValueKind != JsonValueKind.Null)
                 {
+                    var customerPlanId = Guid.Parse(data["customerPlanId"].GetString()!);
+
+                    // A class-linked plan (created from the Classes tab's "Manage Plan" action)
+                    // stacks freely with other class-only plans and with one gym-access plan --
+                    // only a second GYM-ACCESS subscription is blocked. See
+                    // CustomerPlan.GrantsGymAccess.
+                    var grantsGymAccess = await _customerSubscriptionRepository.PlanGrantsGymAccessAsync(customerPlanId);
+
                     // Guard against duplicate active subscriptions at this gym: callers like
                     // the create-existing-customer and edit-customer flows submit whatever plan
                     // is currently shown on the form, not necessarily a deliberate "assign a new
                     // plan" action, so re-submitting an already-assigned plan must not stack a
-                    // second active subscription. Assigning a genuinely different plan belongs to
-                    // ChangeMembershipPlan, which explicitly deactivates the old one first.
-                    var existingActive = await _customerSubscriptionRepository.GetActiveSubscriptionByCustomerId(customerId);
+                    // second active subscription. Assigning a genuinely different GYM plan
+                    // belongs to ChangeMembershipPlan, which explicitly deactivates the old one
+                    // first; a genuinely different CLASS plan is just a new, additional
+                    // subscription (handled below) -- it's only a duplicate of itself that's
+                    // blocked here.
+                    var existingActive = grantsGymAccess
+                        ? await _customerSubscriptionRepository.GetActiveGymAccessSubscriptionAsync(customerId)
+                        : await _customerSubscriptionRepository.GetActiveSubscriptionForPlanAsync(customerId, customerPlanId);
+
                     if (existingActive != null)
                     {
                         alreadyAssigned = true;
@@ -457,15 +471,18 @@ namespace Fitness_core_BE.Services.CustomerService
                     }
                     else
                     {
-                        // Not primary anywhere (checked above), but could still be an active
-                        // secondary on someone else's group plan -- GetActiveSubscriptionByCustomerId
-                        // can't see that (it only matches CustomerSubscription.FKCustomerId, the
-                        // primary). One customer, one plan at a time either way.
-                        var hasOtherActivePlan = await _customerSubscriptionRepository.HasAnyActiveSubscriptionAsync(customerId);
-                        if (hasOtherActivePlan)
-                            throw new ArgumentException("This customer already has an active plan. Remove them from it before assigning a new one.");
+                        if (grantsGymAccess)
+                        {
+                            // Not primary anywhere (checked above), but could still be an active
+                            // secondary on someone else's group plan -- GetActiveGymAccessSubscriptionAsync
+                            // can't see that (it only matches CustomerSubscription.FKCustomerId, the
+                            // primary). One customer, one GYM-ACCESS plan at a time; class-only
+                            // plans are unrestricted.
+                            var hasOtherActiveGymPlan = await _customerSubscriptionRepository.HasActiveGymAccessPlanAsync(customerId);
+                            if (hasOtherActiveGymPlan)
+                                throw new ArgumentException("This customer already has an active plan. Remove them from it before assigning a new one.");
+                        }
 
-                        var customerPlanId = Guid.Parse(data["customerPlanId"].GetString()!);
                         var onboardDate = DataExtractor.GetOptionalDateTime(data, "onboardDate");
                         var chargePayment = DataExtractor.GetOptionalBool(data, "chargePayment") ?? true;
 
@@ -1403,7 +1420,7 @@ namespace Fitness_core_BE.Services.CustomerService
             Guid userId = DataExtractor.GetUserIdFromContext(httpContext);
             Guid cusId = await _userRoleHelper.GetCusId(userId);
 
-            var subscription = await _customerSubscriptionRepository.GetActiveSubscriptionByCustomerId(cusId);
+            var subscription = await _customerSubscriptionRepository.GetActiveGymAccessSubscriptionAsync(cusId);
             if (subscription == null)
                 return new { hasSubscription = false };
 
@@ -1477,7 +1494,7 @@ namespace Fitness_core_BE.Services.CustomerService
                 Guid userId = DataExtractor.GetUserIdFromContext(httpContext);
                 Guid cusId = await _userRoleHelper.GetCusId(userId);
 
-                var customerSubscription = await _customerSubscriptionRepository.GetActiveSubscriptionByCustomerId(cusId);
+                var customerSubscription = await _customerSubscriptionRepository.GetActiveGymAccessSubscriptionAsync(cusId);
 
                 if (customerSubscription != null)
                 {
@@ -1539,7 +1556,7 @@ namespace Fitness_core_BE.Services.CustomerService
             Guid userId = DataExtractor.GetUserIdFromContext(httpContext);
             Guid cusId = await _userRoleHelper.GetCusId(userId);
 
-            var subscription = await _customerSubscriptionRepository.GetActiveSubscriptionByCustomerId(cusId);
+            var subscription = await _customerSubscriptionRepository.GetActiveGymAccessSubscriptionAsync(cusId);
             if (subscription == null)
                 throw new KeyNotFoundException("You don't have an active gym to unfollow.");
 

Services/CustomerSubscriptionService.cs

@@ -182,7 +182,7 @@ namespace Fitness_core_BE.Services.CustomerSubscription
             }
 
             var customerId = Guid.Parse(data["customerId"].GetString()!);
-            var subscription = await _customerSubscriptionRepository.GetActiveSubscriptionByCustomerId(customerId);
+            var subscription = await _customerSubscriptionRepository.GetActiveGymAccessSubscriptionAsync(customerId);
 
             if (subscription == null)
             {
@@ -257,11 +257,15 @@ namespace Fitness_core_BE.Services.CustomerSubscription
                 if (alreadyMember != null)
                     throw new ArgumentException("This customer is already a member of the subscription");
 
-                // One customer, one plan at a time -- catches both "already primary on their own
-                // plan" and "already a secondary on a different group", neither of which the
-                // check above sees (it only looks at this one subscription).
-                var hasOtherActivePlan = await _customerSubscriptionRepository.HasAnyActiveSubscriptionAsync(customerId);
-                if (hasOtherActivePlan)
+                // One customer, one GYM-ACCESS plan at a time -- catches both "already primary
+                // on their own plan" and "already a secondary on a different group", neither of
+                // which the check above sees (it only looks at this one subscription). Group
+                // plans are ordinary gym plans (no class links), so this is always the
+                // gym-access check in practice; left as such rather than a generic
+                // HasAnyActiveSubscriptionAsync so a class-only subscription elsewhere never
+                // blocks joining a group.
+                var hasOtherActiveGymPlan = await _customerSubscriptionRepository.HasActiveGymAccessPlanAsync(customerId);
+                if (hasOtherActiveGymPlan)
                     throw new ArgumentException("This customer already has an active plan. Remove them from it before adding them to another.");
 
                 var member = await _customerSubscriptionRepository.AddSubscriptionMemberAsync(new SubscriptionMember

Services/FacilityService.cs

@@ -10,15 +10,22 @@ namespace Fitness_core_BE.Services
 {
     public class FacilityService : IFacilityService
     {
-        private static readonly string[] ValidBookingModes = ["Scheduled", "AdHoc"];
-
         private readonly IFacilityRepository _facilityRepository;
+        private readonly IClassService _classService;
+        private readonly IBookingService _bookingService;
         private readonly IUnitOfWork _uow;
         private readonly UserRoleHelper _userRoleHelper;
 
-        public FacilityService(IFacilityRepository facilityRepository, IUnitOfWork uow, UserRoleHelper userRoleHelper)
+        public FacilityService(
+            IFacilityRepository facilityRepository,
+            IClassService classService,
+            IBookingService bookingService,
+            IUnitOfWork uow,
+            UserRoleHelper userRoleHelper)
         {
             _facilityRepository = facilityRepository;
+            _classService = classService;
+            _bookingService = bookingService;
             _uow = uow;
             _userRoleHelper = userRoleHelper;
         }
@@ -44,16 +51,17 @@ namespace Fitness_core_BE.Services
                 var data = DeserializePayload.Deserialize(payload);
                 if (!data.ContainsKey("name")) throw new KeyNotFoundException("name is required");
 
-                var bookingMode = data.ContainsKey("bookingMode") ? data["bookingMode"].GetString() ?? "Scheduled" : "Scheduled";
-                if (!ValidBookingModes.Contains(bookingMode))
-                    throw new ArgumentException($"bookingMode must be one of: {string.Join(", ", ValidBookingModes)}");
+                var supportsClasses = data.ContainsKey("supportsClasses") ? data["supportsClasses"].GetBoolean() : true;
+                var supportsBooking = data.ContainsKey("supportsBooking") ? data["supportsBooking"].GetBoolean() : false;
+                if (!supportsClasses && !supportsBooking)
+                    throw new ArgumentException("At least one of SupportsClasses/SupportsBooking must be true");
 
                 var defaultCapacity = data.ContainsKey("defaultCapacity") ? data["defaultCapacity"].GetInt32() : 1;
-                if (bookingMode == "Scheduled" && defaultCapacity < 1)
+                if (supportsClasses && defaultCapacity < 1)
                     throw new ArgumentException("defaultCapacity must be at least 1");
 
                 var numberOfUnits = data.ContainsKey("numberOfUnits") ? data["numberOfUnits"].GetInt32() : 1;
-                if (bookingMode == "AdHoc" && numberOfUnits < 1)
+                if (supportsBooking && numberOfUnits < 1)
                     throw new ArgumentException("numberOfUnits must be at least 1");
 
                 var pricePerHour = data.ContainsKey("pricePerHour") ? data["pricePerHour"].GetDecimal() : 0m;
@@ -66,7 +74,8 @@ namespace Fitness_core_BE.Services
                 {
                     FKClientId = clientId,
                     Name = data["name"].GetString() ?? "",
-                    BookingMode = bookingMode,
+                    SupportsClasses = supportsClasses,
+                    SupportsBooking = supportsBooking,
                     Description = data.ContainsKey("description") ? data["description"].GetString() : null,
                     DefaultCapacity = defaultCapacity,
                     NumberOfUnits = numberOfUnits,
@@ -98,13 +107,16 @@ namespace Fitness_core_BE.Services
                     ?? throw new KeyNotFoundException("Facility not found");
 
                 if (data.ContainsKey("name")) existing.Name = data["name"].GetString() ?? existing.Name;
-                if (data.ContainsKey("bookingMode"))
-                {
-                    var bookingMode = data["bookingMode"].GetString() ?? existing.BookingMode;
-                    if (!ValidBookingModes.Contains(bookingMode))
-                        throw new ArgumentException($"bookingMode must be one of: {string.Join(", ", ValidBookingModes)}");
-                    existing.BookingMode = bookingMode;
-                }
+
+                // Validate on the merged result, not each incoming field in isolation -- e.g.
+                // flipping SupportsClasses off must still leave SupportsBooking (old or new) true.
+                var newSupportsClasses = data.ContainsKey("supportsClasses") ? data["supportsClasses"].GetBoolean() : existing.SupportsClasses;
+                var newSupportsBooking = data.ContainsKey("supportsBooking") ? data["supportsBooking"].GetBoolean() : existing.SupportsBooking;
+                if (!newSupportsClasses && !newSupportsBooking)
+                    throw new ArgumentException("At least one of SupportsClasses/SupportsBooking must be true");
+                existing.SupportsClasses = newSupportsClasses;
+                existing.SupportsBooking = newSupportsBooking;
+
                 if (data.ContainsKey("description")) existing.Description = data["description"].GetString();
                 if (data.ContainsKey("defaultCapacity"))
                 {
@@ -179,8 +191,8 @@ namespace Fitness_core_BE.Services
                 if (facility == null || facility.FKClientId != clientId)
                     throw new KeyNotFoundException("Facility not found");
 
-                if (facility.BookingMode != "Scheduled")
-                    throw new ArgumentException("Sessions can only be created for Scheduled-mode facilities");
+                if (!facility.SupportsClasses)
+                    throw new ArgumentException("Sessions can only be created for facilities that support classes");
 
                 var startTime = DateTime.Parse(data["startTime"].GetString()!).ToUniversalTime();
                 var endTime = DateTime.Parse(data["endTime"].GetString()!).ToUniversalTime();
@@ -228,9 +240,15 @@ namespace Fitness_core_BE.Services
             var toUtc = data.ContainsKey("toDate") && data["toDate"].ValueKind != JsonValueKind.Null
                 ? DateTime.Parse(data["toDate"].GetString()!).ToUniversalTime()
                 : fromUtc.AddDays(7);
+            bool includeCancelled = data.ContainsKey("includeCancelled") && data["includeCancelled"].GetBoolean();
 
             var clientId = await _userRoleHelper.GetClientId(DataExtractor.GetUserIdFromContext(httpContext));
-            var sessions = await _facilityRepository.GetSessions(clientId, facilityId, fromUtc, toUtc);
+
+            // The one read path everything (calendar, class-details occurrence list) already
+            // goes through -- lazy generation here means no background job is needed.
+            await _classService.EnsureOccurrencesGeneratedAsync(clientId);
+
+            var sessions = await _facilityRepository.GetSessions(clientId, facilityId, fromUtc, toUtc, includeCancelled);
 
             var result = new List<FacilitySessionDto>();
             foreach (var session in sessions)
@@ -242,6 +260,13 @@ namespace Fitness_core_BE.Services
             return result;
         }
 
+        /// <summary>"Mark not held" -- sets IsCancelled/NotHeldReason/NotHeldAt and cascades to
+        /// every Confirmed booking on the occurrence: cancels it and refunds any subscription
+        /// allowance, through the exact same core BookingService.CancelBooking uses (one refund
+        /// code path, not two). The freed time becomes bookable again automatically -- the
+        /// walk-in overlap guard only checks non-cancelled sessions. Same entry point as the old
+        /// bare-IsCancelled CancelFacilitySession this replaces; also reachable via the
+        /// memberships-gated facility-classes/.../not-held route for the Classes tab.</summary>
         public async Task<object> CancelFacilitySession(object payload, HttpContext httpContext)
         {
             await _uow.BeginAsync();
@@ -249,11 +274,16 @@ namespace Fitness_core_BE.Services
             {
                 var data = DeserializePayload.Deserialize(payload);
                 var facilitySessionId = Guid.Parse(data["facilitySessionId"].GetString()!);
+                var reason = data.ContainsKey("reason") && data["reason"].ValueKind != JsonValueKind.Null
+                    ? data["reason"].GetString() : null;
 
                 var clientId = await _userRoleHelper.GetClientId(DataExtractor.GetUserIdFromContext(httpContext));
-                var session = await _facilityRepository.CancelFacilitySession(facilitySessionId, clientId)
+                var session = await _facilityRepository.MarkFacilitySessionNotHeldAsync(facilitySessionId, clientId, reason)
                     ?? throw new KeyNotFoundException("Facility session not found");
 
+                foreach (var booking in session.Bookings.Where(b => b.Status == "Confirmed"))
+                    await _bookingService.CancelBookingCore(booking);
+
                 await _uow.CommitAsync();
                 return MapToDto(session);
             }
@@ -335,38 +365,55 @@ namespace Fitness_core_BE.Services
             var result = new List<FacilityAvailabilityDto>();
             foreach (var facility in facilities)
             {
-                if (facility.BookingMode == "AdHoc")
-                {
-                    var overlapping = await _facilityRepository.GetOverlappingAdhocBookingCountAsync(facility.FacilityId, startTime, endTime);
-                    result.Add(new FacilityAvailabilityDto
-                    {
-                        FacilityId = facility.FacilityId,
-                        FacilityName = facility.Name,
-                        BookingMode = facility.BookingMode,
-                        TotalUnits = facility.NumberOfUnits,
-                        UnitsFree = Math.Max(0, facility.NumberOfUnits - overlapping),
-                        PricePerHour = facility.PricePerHour
-                    });
-                }
-                else
-                {
-                    var sessions = await _facilityRepository.GetSessions(clientId, facility.FacilityId, startTime, endTime);
-                    var overlappingSessions = sessions.Where(s => s.StartTime < endTime && s.EndTime > startTime).ToList();
-                    var totalCapacity = overlappingSessions.Sum(s => s.Capacity ?? facility.DefaultCapacity);
-                    var totalBooked = 0;
-                    foreach (var s in overlappingSessions)
-                        totalBooked += await _facilityRepository.GetActiveBookingCount(s.FacilitySessionId);
+                // True interval overlap, not "session starts inside the window" -- a class that
+                // started earlier and is still running must still count.
+                var overlappingSessions = await _facilityRepository.GetOverlappingActiveSessionsAsync(facility.FacilityId, startTime, endTime);
 
-                    result.Add(new FacilityAvailabilityDto
-                    {
-                        FacilityId = facility.FacilityId,
-                        FacilityName = facility.Name,
-                        BookingMode = facility.BookingMode,
-                        TotalUnits = totalCapacity,
-                        UnitsFree = Math.Max(0, totalCapacity - totalBooked),
-                        PricePerHour = facility.PricePerHour
-                    });
+                int? bookingTotal = null, bookingFree = null, classTotal = null, classFree = null;
+                bool classIsUnlimited = false;
+
+                if (facility.SupportsBooking)
+                {
+                    var overlapping = await _facilityRepository.GetOverlappingWalkInBookingCountAsync(facility.FacilityId, startTime, endTime);
+                    bookingTotal = facility.NumberOfUnits;
+                    // A running class occupies the whole facility, not just a seat.
+                    bookingFree = overlappingSessions.Count > 0 ? 0 : Math.Max(0, facility.NumberOfUnits - overlapping);
                 }
+
+                if (facility.SupportsClasses)
+                {
+                    // An unlimited-capacity occurrence has no meaningful total -- Capacity stays
+                    // null on it either way, so summing would silently under-count by falling
+                    // back to the facility default instead of reporting "no cap" at all.
+                    if (overlappingSessions.Any(s => s.IsUnlimitedCapacity))
+                    {
+                        classIsUnlimited = true;
+                    }
+                    else
+                    {
+                        var totalCapacity = overlappingSessions.Sum(s => s.Capacity ?? facility.DefaultCapacity);
+                        var totalBooked = 0;
+                        foreach (var s in overlappingSessions)
+                            totalBooked += await _facilityRepository.GetActiveBookingCount(s.FacilitySessionId);
+
+                        classTotal = totalCapacity;
+                        classFree = Math.Max(0, totalCapacity - totalBooked);
+                    }
+                }
+
+                result.Add(new FacilityAvailabilityDto
+                {
+                    FacilityId = facility.FacilityId,
+                    FacilityName = facility.Name,
+                    SupportsClasses = facility.SupportsClasses,
+                    SupportsBooking = facility.SupportsBooking,
+                    BookingTotalUnits = bookingTotal,
+                    BookingUnitsFree = bookingFree,
+                    ClassTotalCapacity = classTotal,
+                    ClassUnitsFree = classFree,
+                    ClassIsUnlimitedCapacity = classIsUnlimited,
+                    PricePerHour = facility.PricePerHour
+                });
             }
 
             return result;
@@ -376,7 +423,8 @@ namespace Fitness_core_BE.Services
         {
             FacilityId = facility.FacilityId,
             Name = facility.Name,
-            BookingMode = facility.BookingMode,
+            SupportsClasses = facility.SupportsClasses,
+            SupportsBooking = facility.SupportsBooking,
             Description = facility.Description,
             DefaultCapacity = facility.DefaultCapacity,
             NumberOfUnits = facility.NumberOfUnits,
@@ -395,8 +443,13 @@ namespace Fitness_core_BE.Services
             StartTime = session.StartTime,
             EndTime = session.EndTime,
             Capacity = session.Capacity ?? session.Facility?.DefaultCapacity ?? 1,
+            IsUnlimitedCapacity = session.IsUnlimitedCapacity,
             BookedCount = bookedCount,
-            IsCancelled = session.IsCancelled
+            IsCancelled = session.IsCancelled,
+            FacilityClassId = session.FKFacilityClassId,
+            FacilityClassName = session.FacilityClass?.Name,
+            NotHeldReason = session.NotHeldReason,
+            NotHeldAt = session.NotHeldAt
         };
     }
 }

Services/InventoryService.cs

@@ -0,0 +1,734 @@
+using Fitness_core_BE.DTOs.Inventory;
+using Fitness_core_BE.Exceptions;
+using Fitness_core_BE.Helpers;
+using Fitness_core_BE.Infra.UoW;
+using Fitness_core_BE.Interfaces;
+using Fitness_core_BE.Interfaces.Services;
+using Fitness_core_BE.Models;
+using System.Text.Json;
+
+namespace Fitness_core_BE.Services
+{
+    public class InventoryService : IInventoryService
+    {
+        private static readonly string[] ValidReturnCategories =
+            ["Expired", "Damaged", "Lost", "SupplierReturn", "CustomerReturn", "Other"];
+
+        private readonly IInventoryRepository _inventoryRepository;
+        private readonly ICustomerRepository _customerRepository;
+        private readonly IUnitOfWork _uow;
+        private readonly UserRoleHelper _userRoleHelper;
+
+        public InventoryService(
+            IInventoryRepository inventoryRepository,
+            ICustomerRepository customerRepository,
+            IUnitOfWork uow,
+            UserRoleHelper userRoleHelper)
+        {
+            _inventoryRepository = inventoryRepository;
+            _customerRepository = customerRepository;
+            _uow = uow;
+            _userRoleHelper = userRoleHelper;
+        }
+
+        // --- Products ---
+
+        public async Task<object> GetProducts(object payload, HttpContext httpContext)
+        {
+            var data = DeserializePayload.Deserialize(payload);
+            bool includeInactive = data.ContainsKey("includeInactive") && data["includeInactive"].GetBoolean();
+
+            var clientId = await _userRoleHelper.GetClientId(DataExtractor.GetUserIdFromContext(httpContext));
+            var products = await _inventoryRepository.GetProducts(clientId, includeInactive);
+
+            return (await Task.WhenAll(products.Select(MapToDtoAsync))).ToList();
+        }
+
+        public async Task<object> GetProductById(object payload, HttpContext httpContext)
+        {
+            var data = DeserializePayload.Deserialize(payload);
+            var productId = Guid.Parse(data["productId"].GetString()!);
+
+            var clientId = await _userRoleHelper.GetClientId(DataExtractor.GetUserIdFromContext(httpContext));
+            var product = await _inventoryRepository.GetProductById(productId);
+            if (product == null || product.FKClientId != clientId)
+                throw new KeyNotFoundException("Product not found");
+
+            var grnItems = await _inventoryRepository.GetGrnItemsForProduct(productId);
+            var saleItems = await _inventoryRepository.GetSaleItemsForProduct(productId);
+            var returns = await _inventoryRepository.GetStockReturnsForProduct(productId);
+
+            var movements = new List<ProductMovementDto>();
+            movements.AddRange(grnItems.Select(i => new ProductMovementDto
+            {
+                Type = "GRN",
+                Reference = i.Grn?.GrnNumber ?? string.Empty,
+                QuantityChange = i.Quantity,
+                Date = i.Grn?.ReceivedAt ?? DateTime.UtcNow
+            }));
+            movements.AddRange(saleItems.Select(i => new ProductMovementDto
+            {
+                Type = "Sale",
+                Reference = i.Sale?.SaleNumber ?? string.Empty,
+                QuantityChange = -i.Quantity,
+                Date = i.Sale?.SoldAt ?? DateTime.UtcNow
+            }));
+            movements.AddRange(returns.Select(r => new ProductMovementDto
+            {
+                Type = "Return",
+                Reference = r.Category,
+                // CustomerReturn is the one category that adds back to stock -- see
+                // StockReturn's doc comment.
+                QuantityChange = r.Category == "CustomerReturn" ? r.Quantity : -r.Quantity,
+                Date = r.ReturnedAt
+            }));
+            movements = movements.OrderByDescending(m => m.Date).ToList();
+
+            var dto = await MapToDtoAsync(product);
+            return new ProductDetailDto
+            {
+                ProductId = dto.ProductId,
+                Name = dto.Name,
+                Sku = dto.Sku,
+                ImageUrl = dto.ImageUrl,
+                UnitOfMeasure = dto.UnitOfMeasure,
+                CostPrice = dto.CostPrice,
+                SellingPrice = dto.SellingPrice,
+                QuantityOnHand = dto.QuantityOnHand,
+                IsActive = dto.IsActive,
+                CreatedAt = dto.CreatedAt,
+                Movements = movements
+            };
+        }
+
+        public async Task<object> CreateProduct(object payload, HttpContext httpContext)
+        {
+            await _uow.BeginAsync();
+            try
+            {
+                var data = DeserializePayload.Deserialize(payload);
+                if (!data.ContainsKey("name")) throw new KeyNotFoundException("name is required");
+
+                var sellingPrice = data.ContainsKey("sellingPrice") ? data["sellingPrice"].GetDecimal() : 0m;
+                if (sellingPrice < 0) throw new ArgumentException("sellingPrice cannot be negative");
+
+                var clientId = await _userRoleHelper.GetClientId(DataExtractor.GetUserIdFromContext(httpContext));
+
+                var product = new Product
+                {
+                    FKClientId = clientId,
+                    Name = data["name"].GetString() ?? "",
+                    UnitOfMeasure = data.ContainsKey("unitOfMeasure") ? data["unitOfMeasure"].GetString() ?? "pcs" : "pcs",
+                    SellingPrice = sellingPrice
+                };
+
+                var sequence = await _inventoryRepository.GetNextProductSequence(clientId);
+                product.Sku = $"PRD-{sequence:D4}";
+
+                var result = await _inventoryRepository.CreateProduct(product);
+                await _uow.CommitAsync();
+
+                return await MapToDtoAsync(result);
+            }
+            catch
+            {
+                await _uow.RollbackAsync();
+                throw;
+            }
+        }
+
+        public async Task<object> UpdateProduct(object payload, HttpContext httpContext)
+        {
+            await _uow.BeginAsync();
+            try
+            {
+                var data = DeserializePayload.Deserialize(payload);
+                var productId = Guid.Parse(data["productId"].GetString()!);
+
+                var existing = await _inventoryRepository.GetProductById(productId)
+                    ?? throw new KeyNotFoundException("Product not found");
+
+                // Sku is system-generated at creation and never editable here.
+                if (data.ContainsKey("name")) existing.Name = data["name"].GetString() ?? existing.Name;
+                if (data.ContainsKey("unitOfMeasure")) existing.UnitOfMeasure = data["unitOfMeasure"].GetString() ?? existing.UnitOfMeasure;
+                if (data.ContainsKey("sellingPrice"))
+                {
+                    var price = data["sellingPrice"].GetDecimal();
+                    if (price < 0) throw new ArgumentException("sellingPrice cannot be negative");
+                    existing.SellingPrice = price;
+                }
+                if (data.ContainsKey("isActive")) existing.IsActive = data["isActive"].GetBoolean();
+
+                var result = await _inventoryRepository.UpdateProduct(existing);
+                await _uow.CommitAsync();
+
+                return await MapToDtoAsync(result);
+            }
+            catch
+            {
+                await _uow.RollbackAsync();
+                throw;
+            }
+        }
+
+        public async Task<object> UploadProductImage(Guid productId, IFormFile image, HttpContext httpContext)
+        {
+            var clientId = await _userRoleHelper.GetClientId(DataExtractor.GetUserIdFromContext(httpContext));
+            var product = await _inventoryRepository.GetProductById(productId);
+            if (product == null || product.FKClientId != clientId)
+                throw new KeyNotFoundException("Product not found");
+
+            if (image == null || image.Length == 0)
+                throw new BadRequestException("No image file provided.");
+
+            string extension = Path.GetExtension(image.FileName).ToLowerInvariant();
+            string[] allowed = { ".jpg", ".jpeg", ".png", ".webp" };
+            if (!allowed.Contains(extension))
+                throw new BadRequestException("Image must be a jpg, png or webp file.");
+            if (image.Length > 5 * 1024 * 1024)
+                throw new BadRequestException("Image too large (max 5MB).");
+
+            string uploadsRoot = Path.GetFullPath(Path.Combine(Directory.GetCurrentDirectory(), "..", "Uploads", "product-images", clientId.ToString()));
+            if (!Directory.Exists(uploadsRoot))
+                Directory.CreateDirectory(uploadsRoot);
+
+            string filename = $"{productId}_{DateTime.UtcNow:yyyyMMdd_HHmmss}{extension}";
+            string filePath = Path.Combine(uploadsRoot, filename);
+            using (var stream = new FileStream(filePath, FileMode.Create))
+            {
+                await image.CopyToAsync(stream);
+            }
+
+            await _uow.BeginAsync();
+            try
+            {
+                product.ImageId = $"/Uploads/product-images/{clientId}/{Uri.EscapeDataString(filename)}";
+                await _uow.CommitAsync();
+                return await MapToDtoAsync(product);
+            }
+            catch
+            {
+                await _uow.RollbackAsync();
+                throw;
+            }
+        }
+
+        // --- Suppliers ---
+
+        public async Task<object> GetSuppliers(object payload, HttpContext httpContext)
+        {
+            var data = DeserializePayload.Deserialize(payload);
+            bool includeInactive = data.ContainsKey("includeInactive") && data["includeInactive"].GetBoolean();
+
+            var clientId = await _userRoleHelper.GetClientId(DataExtractor.GetUserIdFromContext(httpContext));
+            var suppliers = await _inventoryRepository.GetSuppliers(clientId, includeInactive);
+
+            return suppliers.Select(MapToDto).ToList();
+        }
+
+        public async Task<object> CreateSupplier(object payload, HttpContext httpContext)
+        {
+            await _uow.BeginAsync();
+            try
+            {
+                var data = DeserializePayload.Deserialize(payload);
+                if (!data.ContainsKey("name")) throw new KeyNotFoundException("name is required");
+
+                var clientId = await _userRoleHelper.GetClientId(DataExtractor.GetUserIdFromContext(httpContext));
+
+                var supplier = new Supplier
+                {
+                    FKClientId = clientId,
+                    Name = data["name"].GetString() ?? "",
+                    Phone = data.ContainsKey("phone") && data["phone"].ValueKind != JsonValueKind.Null ? data["phone"].GetString() : null,
+                    Email = data.ContainsKey("email") && data["email"].ValueKind != JsonValueKind.Null ? data["email"].GetString() : null,
+                    Address = data.ContainsKey("address") && data["address"].ValueKind != JsonValueKind.Null ? data["address"].GetString() : null
+                };
+
+                var result = await _inventoryRepository.CreateSupplier(supplier);
+                await _uow.CommitAsync();
+
+                return MapToDto(result);
+            }
+            catch
+            {
+                await _uow.RollbackAsync();
+                throw;
+            }
+        }
+
+        // --- GRN ---
+
+        public async Task<object> CreateGrn(object payload, HttpContext httpContext)
+        {
+            await _uow.BeginAsync();
+            try
+            {
+                var data = DeserializePayload.Deserialize(payload);
+                var clientId = await _userRoleHelper.GetClientId(DataExtractor.GetUserIdFromContext(httpContext));
+
+                // Optional -- some GRNs don't have a supplier on file.
+                Supplier? supplier = null;
+                Guid? supplierId = data.ContainsKey("supplierId") && data["supplierId"].ValueKind != JsonValueKind.Null
+                    ? Guid.Parse(data["supplierId"].GetString()!)
+                    : null;
+                if (supplierId.HasValue)
+                {
+                    supplier = await _inventoryRepository.GetSupplierById(supplierId.Value);
+                    if (supplier == null || supplier.FKClientId != clientId)
+                        throw new KeyNotFoundException("Supplier not found");
+                }
+
+                if (!data.ContainsKey("items") || data["items"].ValueKind != JsonValueKind.Array)
+                    throw new ArgumentException("At least one item is required");
+
+                var receivedAt = data.ContainsKey("receivedAt") && data["receivedAt"].ValueKind != JsonValueKind.Null
+                    ? DateTime.Parse(data["receivedAt"].GetString()!).ToUniversalTime()
+                    : DateTime.UtcNow;
+
+                var grn = new GoodsReceivedNote
+                {
+                    FKClientId = clientId,
+                    FKSupplierId = supplierId,
+                    ReceivedAt = receivedAt,
+                    Notes = data.ContainsKey("notes") && data["notes"].ValueKind != JsonValueKind.Null ? data["notes"].GetString() : null
+                };
+
+                decimal total = 0m;
+                var itemsArray = data["items"].EnumerateArray().ToList();
+                if (itemsArray.Count == 0) throw new ArgumentException("At least one item is required");
+
+                foreach (var itemEl in itemsArray)
+                {
+                    var productId = Guid.Parse(itemEl.GetProperty("productId").GetString()!);
+                    var quantity = itemEl.GetProperty("quantity").GetDecimal();
+                    var unitCost = itemEl.GetProperty("unitCost").GetDecimal();
+
+                    if (quantity <= 0) throw new ArgumentException("Quantity must be greater than 0");
+                    if (unitCost < 0) throw new ArgumentException("UnitCost cannot be negative");
+
+                    var product = await _inventoryRepository.GetProductById(productId);
+                    if (product == null || product.FKClientId != clientId)
+                        throw new KeyNotFoundException("Product not found");
+
+                    var lineTotal = quantity * unitCost;
+                    grn.Items.Add(new GoodsReceivedNoteItem
+                    {
+                        FKProductId = productId,
+                        Quantity = quantity,
+                        UnitCost = unitCost,
+                        LineTotal = lineTotal
+                    });
+
+                    product.QuantityOnHand += quantity;
+                    product.CostPrice = unitCost;
+                    total += lineTotal;
+                }
+
+                grn.TotalAmount = total;
+                var sequence = await _inventoryRepository.GetNextGrnSequence(clientId);
+                grn.GrnNumber = $"GRN-{sequence:D4}";
+
+                var result = await _inventoryRepository.CreateGrn(grn);
+                await _uow.CommitAsync();
+
+                result.Supplier = supplier;
+                return MapToDto(result);
+            }
+            catch
+            {
+                await _uow.RollbackAsync();
+                throw;
+            }
+        }
+
+        public async Task<object> GetGrns(object payload, HttpContext httpContext)
+        {
+            var clientId = await _userRoleHelper.GetClientId(DataExtractor.GetUserIdFromContext(httpContext));
+            var grns = await _inventoryRepository.GetGrns(clientId);
+            return grns.Select(MapToDto).ToList();
+        }
+
+        public async Task<object> GetGrnById(object payload, HttpContext httpContext)
+        {
+            var data = DeserializePayload.Deserialize(payload);
+            var grnId = Guid.Parse(data["grnId"].GetString()!);
+
+            var clientId = await _userRoleHelper.GetClientId(DataExtractor.GetUserIdFromContext(httpContext));
+            var grn = await _inventoryRepository.GetGrnById(grnId);
+            if (grn == null || grn.FKClientId != clientId)
+                throw new KeyNotFoundException("GRN not found");
+
+            return MapToDto(grn);
+        }
+
+        // --- Sales ---
+
+        public async Task<object> CreateSale(object payload, HttpContext httpContext)
+        {
+            await _uow.BeginAsync();
+            try
+            {
+                var data = DeserializePayload.Deserialize(payload);
+                var clientId = await _userRoleHelper.GetClientId(DataExtractor.GetUserIdFromContext(httpContext));
+
+                var paymentMethod = data.ContainsKey("paymentMethod") && data["paymentMethod"].ValueKind != JsonValueKind.Null
+                    ? data["paymentMethod"].GetString() ?? "Cash" : "Cash";
+
+                var customerId = await ResolveOptionalCustomerLinkAsync(data);
+
+                if (!data.ContainsKey("items") || data["items"].ValueKind != JsonValueKind.Array)
+                    throw new ArgumentException("At least one item is required");
+
+                var soldAt = data.ContainsKey("soldAt") && data["soldAt"].ValueKind != JsonValueKind.Null
+                    ? DateTime.Parse(data["soldAt"].GetString()!).ToUniversalTime()
+                    : DateTime.UtcNow;
+
+                var sale = new Sale
+                {
+                    FKClientId = clientId,
+                    SoldAt = soldAt,
+                    PaymentMethod = paymentMethod,
+                    FKCustomerId = customerId,
+                    CustomerName = data.ContainsKey("customerName") && data["customerName"].ValueKind != JsonValueKind.Null
+                        ? data["customerName"].GetString() : null
+                };
+
+                decimal total = 0m;
+                var itemsArray = data["items"].EnumerateArray().ToList();
+                if (itemsArray.Count == 0) throw new ArgumentException("At least one item is required");
+
+                // Load + validate every line before mutating stock, so a short line rejects the
+                // whole sale rather than partially decrementing earlier lines.
+                var lines = new List<(Product Product, decimal Quantity, decimal UnitPrice)>();
+                foreach (var itemEl in itemsArray)
+                {
+                    var productId = Guid.Parse(itemEl.GetProperty("productId").GetString()!);
+                    var quantity = itemEl.GetProperty("quantity").GetDecimal();
+                    var unitPrice = itemEl.GetProperty("unitPrice").GetDecimal();
+
+                    if (quantity <= 0) throw new ArgumentException("Quantity must be greater than 0");
+                    if (unitPrice < 0) throw new ArgumentException("UnitPrice cannot be negative");
+
+                    var product = await _inventoryRepository.GetProductById(productId);
+                    if (product == null || product.FKClientId != clientId)
+                        throw new KeyNotFoundException("Product not found");
+                    if (product.QuantityOnHand < quantity)
+                        throw new ArgumentException($"Not enough stock for \"{product.Name}\" (have {product.QuantityOnHand}, need {quantity})");
+
+                    lines.Add((product, quantity, unitPrice));
+                }
+
+                foreach (var (product, quantity, unitPrice) in lines)
+                {
+                    var lineTotal = quantity * unitPrice;
+                    sale.Items.Add(new SaleItem
+                    {
+                        FKProductId = product.ProductId,
+                        Quantity = quantity,
+                        UnitPrice = unitPrice,
+                        LineTotal = lineTotal
+                    });
+
+                    product.QuantityOnHand -= quantity;
+                    total += lineTotal;
+                }
+
+                sale.TotalAmount = total;
+                var sequence = await _inventoryRepository.GetNextSaleSequence(clientId);
+                sale.SaleNumber = $"SALE-{sequence:D4}";
+
+                var result = await _inventoryRepository.CreateSale(sale);
+                await _uow.CommitAsync();
+
+                return MapToDto(result);
+            }
+            catch
+            {
+                await _uow.RollbackAsync();
+                throw;
+            }
+        }
+
+        public async Task<object> GetSales(object payload, HttpContext httpContext)
+        {
+            var clientId = await _userRoleHelper.GetClientId(DataExtractor.GetUserIdFromContext(httpContext));
+            var sales = await _inventoryRepository.GetSales(clientId);
+            return sales.Select(MapToDto).ToList();
+        }
+
+        public async Task<object> GetSaleById(object payload, HttpContext httpContext)
+        {
+            var data = DeserializePayload.Deserialize(payload);
+            var saleId = Guid.Parse(data["saleId"].GetString()!);
+
+            var clientId = await _userRoleHelper.GetClientId(DataExtractor.GetUserIdFromContext(httpContext));
+            var sale = await _inventoryRepository.GetSaleById(saleId);
+            if (sale == null || sale.FKClientId != clientId)
+                throw new KeyNotFoundException("Sale not found");
+
+            return MapToDto(sale);
+        }
+
+        // --- Returns ---
+
+        public async Task<object> CreateStockReturn(object payload, HttpContext httpContext)
+        {
+            await _uow.BeginAsync();
+            try
+            {
+                var data = DeserializePayload.Deserialize(payload);
+                var clientId = await _userRoleHelper.GetClientId(DataExtractor.GetUserIdFromContext(httpContext));
+
+                var productId = Guid.Parse(data["productId"].GetString()!);
+                var quantity = data["quantity"].GetDecimal();
+                if (quantity <= 0) throw new ArgumentException("Quantity must be greater than 0");
+
+                var category = data["category"].GetString() ?? "Other";
+                if (!ValidReturnCategories.Contains(category))
+                    throw new ArgumentException($"category must be one of: {string.Join(", ", ValidReturnCategories)}");
+
+                var product = await _inventoryRepository.GetProductById(productId);
+                if (product == null || product.FKClientId != clientId)
+                    throw new KeyNotFoundException("Product not found");
+
+                // CustomerReturn is the one category that adds back to stock -- the item
+                // physically comes back after an earlier sale already removed it, so there's no
+                // "enough stock on hand" requirement (it may well be at 0). Every other category
+                // removes from stock we currently hold, so it does require enough on hand.
+                var addsBackToStock = category == "CustomerReturn";
+                if (!addsBackToStock && product.QuantityOnHand < quantity)
+                    throw new ArgumentException($"Not enough stock for \"{product.Name}\" (have {product.QuantityOnHand}, need {quantity})");
+
+                // Optional traceability -- most returns have neither. Only validated for
+                // existence/ownership, not cross-checked against the product/quantity.
+                Guid? saleId = data.ContainsKey("saleId") && data["saleId"].ValueKind != JsonValueKind.Null
+                    ? Guid.Parse(data["saleId"].GetString()!) : null;
+                Sale? sale = null;
+                if (saleId.HasValue)
+                {
+                    sale = await _inventoryRepository.GetSaleById(saleId.Value);
+                    if (sale == null || sale.FKClientId != clientId)
+                        throw new KeyNotFoundException("Sale not found");
+                }
+
+                Guid? grnId = data.ContainsKey("grnId") && data["grnId"].ValueKind != JsonValueKind.Null
+                    ? Guid.Parse(data["grnId"].GetString()!) : null;
+                GoodsReceivedNote? grn = null;
+                if (grnId.HasValue)
+                {
+                    grn = await _inventoryRepository.GetGrnById(grnId.Value);
+                    if (grn == null || grn.FKClientId != clientId)
+                        throw new KeyNotFoundException("GRN not found");
+                }
+
+                var returnedAt = data.ContainsKey("returnedAt") && data["returnedAt"].ValueKind != JsonValueKind.Null
+                    ? DateTime.Parse(data["returnedAt"].GetString()!).ToUniversalTime()
+                    : DateTime.UtcNow;
+
+                var stockReturn = new StockReturn
+                {
+                    FKClientId = clientId,
+                    FKProductId = productId,
+                    Quantity = quantity,
+                    Category = category,
+                    FKSaleId = saleId,
+                    FKGrnId = grnId,
+                    Notes = data.ContainsKey("notes") && data["notes"].ValueKind != JsonValueKind.Null ? data["notes"].GetString() : null,
+                    ReturnedAt = returnedAt,
+                    Amount = quantity * product.CostPrice
+                };
+
+                product.QuantityOnHand += addsBackToStock ? quantity : -quantity;
+
+                var result = await _inventoryRepository.CreateStockReturn(stockReturn);
+                await _uow.CommitAsync();
+
+                result.Product = product;
+                result.Sale = sale;
+                result.Grn = grn;
+                return MapToDto(result);
+            }
+            catch
+            {
+                await _uow.RollbackAsync();
+                throw;
+            }
+        }
+
+        public async Task<object> GetStockReturns(object payload, HttpContext httpContext)
+        {
+            var clientId = await _userRoleHelper.GetClientId(DataExtractor.GetUserIdFromContext(httpContext));
+            var returns = await _inventoryRepository.GetStockReturns(clientId);
+            return returns.Select(MapToDto).ToList();
+        }
+
+        public async Task<object> GetStockReturnById(object payload, HttpContext httpContext)
+        {
+            var data = DeserializePayload.Deserialize(payload);
+            var stockReturnId = Guid.Parse(data["stockReturnId"].GetString()!);
+
+            var clientId = await _userRoleHelper.GetClientId(DataExtractor.GetUserIdFromContext(httpContext));
+            var stockReturn = await _inventoryRepository.GetStockReturnById(stockReturnId);
+            if (stockReturn == null || stockReturn.FKClientId != clientId)
+                throw new KeyNotFoundException("Return not found");
+
+            return MapToDto(stockReturn);
+        }
+
+        // --- Stock Tracking (unified ledger, new) ---
+
+        /// <summary>Every GRN line, sale line and return across every product, flattened into one
+        /// shape for the Stock Tracking tab's table. Built from the same three already-tenant-
+        /// scoped reads the GRN/Sales/Returns tabs use -- no new repository queries needed, and
+        /// the dataset is small enough (a single gym's "simple inventory") that filtering happens
+        /// client-side rather than via query params.</summary>
+        public async Task<object> GetStockMovements(object payload, HttpContext httpContext)
+        {
+            var clientId = await _userRoleHelper.GetClientId(DataExtractor.GetUserIdFromContext(httpContext));
+
+            var grns = await _inventoryRepository.GetGrns(clientId);
+            var sales = await _inventoryRepository.GetSales(clientId);
+            var returns = await _inventoryRepository.GetStockReturns(clientId);
+
+            var movements = new List<StockMovementDto>();
+
+            foreach (var g in grns)
+                foreach (var i in g.Items)
+                    movements.Add(new StockMovementDto
+                    {
+                        Type = "GRN",
+                        ProductId = i.FKProductId,
+                        ProductName = i.Product?.Name ?? string.Empty,
+                        Reference = g.GrnNumber,
+                        QuantityChange = i.Quantity,
+                        Amount = i.LineTotal,
+                        Date = g.ReceivedAt
+                    });
+
+            foreach (var s in sales)
+                foreach (var i in s.Items)
+                    movements.Add(new StockMovementDto
+                    {
+                        Type = "Sale",
+                        ProductId = i.FKProductId,
+                        ProductName = i.Product?.Name ?? string.Empty,
+                        Reference = s.SaleNumber,
+                        QuantityChange = -i.Quantity,
+                        Amount = i.LineTotal,
+                        Date = s.SoldAt
+                    });
+
+            foreach (var r in returns)
+                movements.Add(new StockMovementDto
+                {
+                    Type = "Return",
+                    ProductId = r.FKProductId,
+                    ProductName = r.Product?.Name ?? string.Empty,
+                    Reference = r.Sale?.SaleNumber ?? r.Grn?.GrnNumber ?? r.Category,
+                    Category = r.Category,
+                    // CustomerReturn is the one category that adds back to stock -- see
+                    // StockReturn's doc comment.
+                    QuantityChange = r.Category == "CustomerReturn" ? r.Quantity : -r.Quantity,
+                    Amount = r.Amount,
+                    Date = r.ReturnedAt
+                });
+
+            return movements.OrderByDescending(m => m.Date).ToList();
+        }
+
+        /// <summary>Staff optionally picking an existing registered member to attach to a sale
+        /// (search-and-pick, not free-typed) -- purely for identification, mirrors
+        /// BookingService.ResolveOptionalCustomerLinkAsync exactly.</summary>
+        private async Task<Guid?> ResolveOptionalCustomerLinkAsync(Dictionary<string, JsonElement> data)
+        {
+            if (!data.ContainsKey("customerId") || data["customerId"].ValueKind == JsonValueKind.Null)
+                return null;
+
+            var customerId = Guid.Parse(data["customerId"].GetString()!);
+            _ = await _customerRepository.GetTenantCustomerLinkById(customerId)
+                ?? throw new KeyNotFoundException("Customer not found");
+            return customerId;
+        }
+
+        // ImageId is a relative /Uploads path (same convention as ClientBusiness.BusinessLogoId)
+        // with no static-file serving configured for it, so it's inlined as a base64 data URL.
+        private static async Task<ProductDto> MapToDtoAsync(Product p) => new()
+        {
+            ProductId = p.ProductId,
+            Name = p.Name,
+            Sku = p.Sku,
+            ImageUrl = await BusinessLogoHelper.ReadAsDataUrlAsync(p.ImageId),
+            UnitOfMeasure = p.UnitOfMeasure,
+            CostPrice = p.CostPrice,
+            SellingPrice = p.SellingPrice,
+            QuantityOnHand = p.QuantityOnHand,
+            IsActive = p.IsActive,
+            CreatedAt = p.CreatedAt
+        };
+
+        private static SupplierDto MapToDto(Supplier s) => new()
+        {
+            SupplierId = s.SupplierId,
+            Name = s.Name,
+            Phone = s.Phone,
+            Email = s.Email,
+            Address = s.Address,
+            IsActive = s.IsActive
+        };
+
+        private static GoodsReceivedNoteDto MapToDto(GoodsReceivedNote g) => new()
+        {
+            GrnId = g.GrnId,
+            GrnNumber = g.GrnNumber,
+            SupplierId = g.FKSupplierId,
+            SupplierName = g.Supplier?.Name,
+            ReceivedAt = g.ReceivedAt,
+            Notes = g.Notes,
+            TotalAmount = g.TotalAmount,
+            Items = g.Items.Select(i => new GoodsReceivedNoteItemDto
+            {
+                ProductId = i.FKProductId,
+                ProductName = i.Product?.Name ?? string.Empty,
+                Quantity = i.Quantity,
+                UnitCost = i.UnitCost,
+                LineTotal = i.LineTotal
+            }).ToList()
+        };
+
+        private static SaleDto MapToDto(Sale s) => new()
+        {
+            SaleId = s.SaleId,
+            SaleNumber = s.SaleNumber,
+            SoldAt = s.SoldAt,
+            PaymentMethod = s.PaymentMethod,
+            CustomerId = s.FKCustomerId,
+            CustomerName = s.CustomerName,
+            TotalAmount = s.TotalAmount,
+            Items = s.Items.Select(i => new SaleItemDto
+            {
+                ProductId = i.FKProductId,
+                ProductName = i.Product?.Name ?? string.Empty,
+                Quantity = i.Quantity,
+                UnitPrice = i.UnitPrice,
+                LineTotal = i.LineTotal
+            }).ToList()
+        };
+
+        private static StockReturnDto MapToDto(StockReturn r) => new()
+        {
+            StockReturnId = r.StockReturnId,
+            ProductId = r.FKProductId,
+            ProductName = r.Product?.Name ?? string.Empty,
+            Quantity = r.Quantity,
+            Category = r.Category,
+            SaleId = r.FKSaleId,
+            SaleNumber = r.Sale?.SaleNumber,
+            GrnId = r.FKGrnId,
+            GrnNumber = r.Grn?.GrnNumber,
+            Notes = r.Notes,
+            ReturnedAt = r.ReturnedAt,
+            Amount = r.Amount
+        };
+    }
+}

Services/SubscriptionRenewalJob.cs

@@ -25,7 +25,7 @@ namespace Fitness_core_BE.Services
         // SubscriptionRenewalRunner still use DateTime.UtcNow, unaffected by this -- only the
         // wake-up point shifts.
         private static readonly TimeSpan RunAtLocal = TimeSpan.FromHours(1);
-        private static readonly TimeZoneInfo SriLankaTimeZone = ResolveSriLankaTimeZone();
+        private static readonly TimeZoneInfo SriLankaTimeZone = Helpers.TimeZoneHelper.SriLanka;
 
         private readonly IServiceScopeFactory _scopeFactory;
         private readonly ILogger<SubscriptionRenewalJob> _logger;
@@ -68,29 +68,6 @@ namespace Fitness_core_BE.Services
             }
         }
 
-        private static TimeZoneInfo ResolveSriLankaTimeZone()
-        {
-            try
-            {
-                return TimeZoneInfo.FindSystemTimeZoneById("Sri Lanka Standard Time"); // Windows ID
-            }
-            catch (TimeZoneNotFoundException)
-            {
-                try
-                {
-                    return TimeZoneInfo.FindSystemTimeZoneById("Asia/Colombo"); // IANA ID (Linux/macOS)
-                }
-                catch (TimeZoneNotFoundException)
-                {
-                    // Neither ID resolved (e.g. no tzdata on the host) -- Sri Lanka has kept a
-                    // fixed UTC+5:30 offset with no DST since 2006, so a custom fixed-offset
-                    // zone is a safe fallback rather than failing the whole job.
-                    return TimeZoneInfo.CreateCustomTimeZone(
-                        "Sri Lanka (fixed +05:30)", TimeSpan.FromMinutes(330), "Sri Lanka Time", "Sri Lanka Time");
-                }
-            }
-        }
-
         // Delay-then-run, not run-then-delay: a fixed daily time trigger shouldn't fire an extra
         // run just because the app happened to restart. Internal + static so it's unit-testable
         // without spinning up the whole hosted service.

TenantDbContext.cs

@@ -73,6 +73,11 @@ namespace Fitness_core_BE
         public DbSet<TimeBankCardUsageLog> TimeBankCardUsageLogs => Set<TimeBankCardUsageLog>();
         public DbSet<CustomerPlanFacility> CustomerPlanFacilities => Set<CustomerPlanFacility>();
 
+        // Recurring class definitions + their generated FacilitySession occurrences (see
+        // Models/FacilityClass.cs), and which CustomerPlan(s) are sold against a class.
+        public DbSet<FacilityClass> FacilityClasses => Set<FacilityClass>();
+        public DbSet<CustomerPlanClass> CustomerPlanClasses => Set<CustomerPlanClass>();
+
         // Booking-scoped RFID tag inventory (assigned to a Booking at check-in, released at
         // Complete/no-show sweep) -- see Models/RfidTag.cs. Not to be confused with
         // TimeBankCard's own, unrelated RfidTagId string field.
@@ -82,6 +87,16 @@ namespace Fitness_core_BE
         // Models/BookingInvoice.cs. Deliberately separate from CustomerInvoice (membership-only).
         public DbSet<BookingInvoice> BookingInvoices => Set<BookingInvoice>();
 
+        // Simple inventory: Products, Suppliers, GRN (stock in), Sales (stock out), Returns
+        // (stock write-offs) -- see each model's own doc comment.
+        public DbSet<Product> Products => Set<Product>();
+        public DbSet<Supplier> Suppliers => Set<Supplier>();
+        public DbSet<GoodsReceivedNote> GoodsReceivedNotes => Set<GoodsReceivedNote>();
+        public DbSet<GoodsReceivedNoteItem> GoodsReceivedNoteItems => Set<GoodsReceivedNoteItem>();
+        public DbSet<Sale> Sales => Set<Sale>();
+        public DbSet<SaleItem> SaleItems => Set<SaleItem>();
+        public DbSet<StockReturn> StockReturns => Set<StockReturn>();
+
         protected override void OnModelCreating(ModelBuilder modelBuilder)
         {
             base.OnModelCreating(modelBuilder);
@@ -187,18 +202,24 @@ namespace Fitness_core_BE
             // doesn't, since Client lives only in CentralDbContext).
             modelBuilder.Entity<Facility>().Ignore(f => f.Client);
             modelBuilder.Entity<FacilitySession>().Ignore(s => s.Client);
+            modelBuilder.Entity<FacilityClass>().Ignore(fc => fc.Client);
             modelBuilder.Entity<Booking>().Ignore(b => b.Client);
             modelBuilder.Entity<BookingInvoice>().Ignore(i => i.Client);
             modelBuilder.Entity<TimeBankCard>().Ignore(t => t.Client);
             modelBuilder.Entity<TimeBankCardUsageLog>().Ignore(l => l.Client);
+            modelBuilder.Entity<Product>().Ignore(p => p.Client);
+            modelBuilder.Entity<Supplier>().Ignore(s => s.Client);
+            modelBuilder.Entity<GoodsReceivedNote>().Ignore(g => g.Client);
+            modelBuilder.Entity<Sale>().Ignore(s => s.Client);
+            modelBuilder.Entity<StockReturn>().Ignore(r => r.Client);
 
             // A session's capacity is enforced by counting non-cancelled bookings against it at
             // booking time, not by a unique index -- multiple guests/members can share one slot
             // up to Facility.DefaultCapacity. What must stay unique is a member double-booking
-            // the same session twice. FKFacilitySessionId is null for every AdHoc booking, and
+            // the same session twice. FKFacilitySessionId is null for every WalkIn booking, and
             // MySQL/InnoDB never treats two NULLs as duplicates in a unique index, so this index
-            // is naturally a no-op for AdHoc bookings -- their own overlap-vs-NumberOfUnits check
-            // lives in BookingRepository.GetOverlappingAdhocBookingCountAsync instead.
+            // is naturally a no-op for WalkIn bookings -- their own overlap-vs-NumberOfUnits check
+            // lives in FacilityRepository.GetOverlappingWalkInBookingCountAsync instead.
             modelBuilder.Entity<Booking>()
                 .HasIndex(b => new { b.FKFacilitySessionId, b.FKCustomerId })
                 .IsUnique()
@@ -207,6 +228,17 @@ namespace Fitness_core_BE
             modelBuilder.Entity<FacilitySession>()
                 .HasIndex(s => new { s.FKFacilityId, s.StartTime });
 
+            modelBuilder.Entity<FacilityClass>()
+                .HasIndex(fc => fc.FKFacilityId);
+
+            // Guards against double-generating the same occurrence when two concurrent calendar
+            // loads both trigger EnsureOccurrencesGeneratedAsync for the same class -- a dedup
+            // check in code alone isn't race-safe. MySQL unique indexes ignore NULL, so every
+            // pre-existing, non-class session (FKFacilityClassId null) is unaffected.
+            modelBuilder.Entity<FacilitySession>()
+                .HasIndex(s => new { s.FKFacilityClassId, s.StartTime })
+                .IsUnique();
+
             modelBuilder.Entity<TimeBankCard>()
                 .HasIndex(t => t.RfidTagId)
                 .IsUnique();
@@ -268,15 +300,25 @@ namespace Fitness_core_BE
                 .HasOne(pf => pf.Facility).WithMany()
                 .HasForeignKey(pf => pf.FKFacilityId).OnDelete(DeleteBehavior.Restrict);
 
+            modelBuilder.Entity<CustomerPlanClass>()
+                .HasIndex(pc => new { pc.FKCustomerPlanId, pc.FKFacilityClassId })
+                .IsUnique();
+            modelBuilder.Entity<CustomerPlanClass>()
+                .HasOne(pc => pc.CustomerPlan).WithMany()
+                .HasForeignKey(pc => pc.FKCustomerPlanId).OnDelete(DeleteBehavior.Cascade);
+            modelBuilder.Entity<CustomerPlanClass>()
+                .HasOne(pc => pc.FacilityClass).WithMany()
+                .HasForeignKey(pc => pc.FKFacilityClassId).OnDelete(DeleteBehavior.Restrict);
+
             // RFID tag inventory is per-client; a tag code only needs to be unique within one
             // club's pool.
             modelBuilder.Entity<RfidTag>()
                 .HasIndex(t => new { t.FKClientId, t.TagCode })
                 .IsUnique();
 
-            // AdHoc bookings share a facility's NumberOfUnits, checked by counting overlapping
+            // WalkIn bookings share a facility's NumberOfUnits, checked by counting overlapping
             // non-cancelled/non-completed bookings at creation/reschedule time (see
-            // BookingRepository.GetOverlappingAdhocBookingCountAsync) rather than a DB
+            // FacilityRepository.GetOverlappingWalkInBookingCountAsync) rather than a DB
             // constraint -- an exclusion constraint over a time range isn't expressible as a
             // simple unique index, and MySQL/Pomelo has no range-overlap index type. This index
             // just makes that overlap query efficient.
@@ -286,6 +328,45 @@ namespace Fitness_core_BE
             modelBuilder.Entity<BookingInvoice>()
                 .HasIndex(i => new { i.FKClientId, i.IssuedAt });
 
+            // Inventory: GRN/Sale items cascade with their header; Return/GRN/Sale restrict
+            // deleting a Product/Supplier that already has history (there's no delete endpoint
+            // for either, but Restrict keeps the data model honest either way).
+            modelBuilder.Entity<Product>()
+                .HasIndex(p => new { p.FKClientId, p.Name });
+            modelBuilder.Entity<Supplier>()
+                .HasIndex(s => new { s.FKClientId, s.Name });
+            modelBuilder.Entity<GoodsReceivedNote>()
+                .HasIndex(g => new { g.FKClientId, g.ReceivedAt });
+            modelBuilder.Entity<GoodsReceivedNote>()
+                .HasOne(g => g.Supplier).WithMany()
+                .HasForeignKey(g => g.FKSupplierId).OnDelete(DeleteBehavior.Restrict);
+            modelBuilder.Entity<GoodsReceivedNoteItem>()
+                .HasOne(i => i.Grn).WithMany(g => g.Items)
+                .HasForeignKey(i => i.FKGrnId).OnDelete(DeleteBehavior.Cascade);
+            modelBuilder.Entity<GoodsReceivedNoteItem>()
+                .HasOne(i => i.Product).WithMany()
+                .HasForeignKey(i => i.FKProductId).OnDelete(DeleteBehavior.Restrict);
+            modelBuilder.Entity<Sale>()
+                .HasIndex(s => new { s.FKClientId, s.SoldAt });
+            modelBuilder.Entity<SaleItem>()
+                .HasOne(i => i.Sale).WithMany(s => s.Items)
+                .HasForeignKey(i => i.FKSaleId).OnDelete(DeleteBehavior.Cascade);
+            modelBuilder.Entity<SaleItem>()
+                .HasOne(i => i.Product).WithMany()
+                .HasForeignKey(i => i.FKProductId).OnDelete(DeleteBehavior.Restrict);
+            modelBuilder.Entity<StockReturn>()
+                .HasIndex(r => new { r.FKClientId, r.ReturnedAt });
+            modelBuilder.Entity<StockReturn>()
+                .HasOne(r => r.Product).WithMany()
+                .HasForeignKey(r => r.FKProductId).OnDelete(DeleteBehavior.Restrict);
+            // Optional traceability links -- most returns have neither.
+            modelBuilder.Entity<StockReturn>()
+                .HasOne(r => r.Sale).WithMany()
+                .HasForeignKey(r => r.FKSaleId).OnDelete(DeleteBehavior.Restrict);
+            modelBuilder.Entity<StockReturn>()
+                .HasOne(r => r.Grn).WithMany()
+                .HasForeignKey(r => r.FKGrnId).OnDelete(DeleteBehavior.Restrict);
+
             modelBuilder.Entity<UnlinkedDeviceEnrollment>()
                 .HasIndex(e => new { e.FKDeviceId, e.DeviceEmployeeNo, e.LinkedAt });