@happychef/algorithm 1.0.0

package/isDateAvailable.js

@@ -0,0 +1,77 @@
+// isDateAvailable.js
+
+const { getAvailableTimeblocks } = require('./getAvailableTimeblocks');
+
+/**
+ * Parses a time string in "HH:MM" format into minutes since midnight.
+ * @param {string} timeStr - Time string in "HH:MM" format.
+ * @returns {number} Minutes since midnight.
+ */
+function parseTime(timeStr) {
+  const [hours, minutes] = timeStr.split(':').map(Number);
+  return hours * 60 + minutes;
+}
+
+/**
+ * Checks if a date is within the allowed future range defined by dagenInToekomst.
+ * @param {Object} data - The main data object (to access general settings).
+ * @param {string} dateStr - The date string (YYYY-MM-DD).
+ * @returns {boolean} true if within range, false otherwise.
+ */
+function isDateWithinAllowedRange(data, dateStr) {
+  // Get dagenInToekomst
+  let dagenInToekomst = 90;
+  if (
+    data['general-settings'] &&
+    data['general-settings'].dagenInToekomst &&
+    parseInt(data['general-settings'].dagenInToekomst, 10) > 0
+  ) {
+    dagenInToekomst = parseInt(data['general-settings'].dagenInToekomst, 10);
+  }
+
+  const timeZone = 'Europe/Amsterdam';
+
+  const now = new Date();
+  const currentTimeInTimeZone = new Date(
+    now.toLocaleString('en-US', { timeZone: timeZone })
+  );
+
+  const maxAllowedDate = new Date(currentTimeInTimeZone.getTime());
+  maxAllowedDate.setDate(maxAllowedDate.getDate() + dagenInToekomst);
+  maxAllowedDate.setHours(23, 59, 59, 999);
+
+  const [year, month, day] = dateStr.split('-').map(Number);
+  const targetDate = new Date(Date.UTC(year, month - 1, day));
+  const targetDateInTimeZone = new Date(
+    targetDate.toLocaleString('en-US', { timeZone: timeZone })
+  );
+
+  return targetDateInTimeZone <= maxAllowedDate;
+}
+
+/**
+ * Checks if a date is available for a reservation of a specified number of guests.
+ * This updated version uses `getAvailableTimeblocks` to ensure that it never returns
+ * true if no actual time slots are available, including for today's date.
+ * @param {Object} data - The main data object containing settings and meal information.
+ * @param {string} dateStr - The date string in "YYYY-MM-DD" format.
+ * @param {Array} reservations - An array of reservation objects.
+ * @param {number} guests - The number of guests for the reservation.
+ * @returns {boolean} - Returns true if the date has at least one available timeblock, false otherwise.
+ */
+function isDateAvailable(data, dateStr, reservations, guests) {
+  // Check if date is within allowed range
+  if (!isDateWithinAllowedRange(data, dateStr)) {
+    return false;
+  }
+
+  // Get available timeblocks using the existing logic
+  const availableTimeblocks = getAvailableTimeblocks(data, dateStr, reservations, guests);
+
+  // Return true only if we have at least one available timeblock
+  return Object.keys(availableTimeblocks).length > 0;
+}
+
+module.exports = {
+  isDateAvailable,
+};

package/isDateAvailableWithTableCheck.js

@@ -0,0 +1,169 @@
+// file: /src/Pages/NewReservation/StepOne/algorithm/isDateAvailableWithTableCheck.js
+const moment = require('moment-timezone');
+const { isDateAvailable } = require('./isDateAvailable');
+const { getAvailableTimeblocks } = require('./getAvailableTimeblocks');
+const { isTimeAvailableSync } = require('./simulateTableAssignment');
+const { daysOfWeekEnglish, getMealTypeByTime } = require('./restaurant_data/openinghours');
+
+const TIMEZONE = 'Europe/Brussels';
+
+/**
+ * Checks if the specific meal/time also contains the giftcard. 
+ * For instance, if Wednesday-lunch includes "Woensdag bon," 
+ * but the user picks 19:00 (dinner), we should exclude that time.
+ *
+ * @param {Object} data - The restaurant data object.
+ * @param {string} dateStr - "YYYY-MM-DD".
+ * @param {string} timeStr - "HH:MM".
+ * @param {string} giftcard - The selected giftcard.
+ * @returns {boolean} true if the meal block for timeStr on dateStr includes the giftcard, else false.
+ */
+function timeHasGiftcard(data, dateStr, timeStr, giftcard) {
+  if (!giftcard || !giftcard.trim()) return true; // No giftcard => no restriction
+
+  // Figure out the meal type from timeStr
+  const mealType = getMealTypeByTime(timeStr); // returns "breakfast", "lunch", or "dinner"
+  if (!mealType) {
+    return false; // Not in any recognized meal
+  }
+
+  // Day-of-week in Brussels TZ
+  const m = moment.tz(dateStr, 'YYYY-MM-DD', TIMEZONE);
+  if (!m.isValid()) return false;
+  const englishDay = daysOfWeekEnglish[m.day()];
+
+  const ohKey = `openinghours-${mealType}`;
+  const daySettings =
+    data[ohKey] &&
+    data[ohKey].schemeSettings &&
+    data[ohKey].schemeSettings[englishDay]
+      ? data[ohKey].schemeSettings[englishDay]
+      : null;
+
+  if (!daySettings) {
+    console.error(`No day settings found for ${englishDay} ${mealType}`);
+    return false;
+  }
+
+  if (daySettings.giftcardsEnabled !== true) {
+    return false;
+  }
+  
+  if (!Array.isArray(daySettings.giftcards) || daySettings.giftcards.length === 0) {
+    return false;
+  }
+
+  // Check if the selected giftcard is in the allowed list
+  return daySettings.giftcards.includes(giftcard);
+}
+
+/**
+ * Checks if a date is available for a reservation with a table assignment check.
+ * This extends isDateAvailable by also verifying that at least one time slot
+ * has an available table AND (if giftcard is selected) that the time belongs
+ * to a meal that includes that giftcard. It also filters dates based on the
+ * selected menu item's filterStartDate and filterEndDate from
+ * window.currentReservationTicketItem, but only when normalOpeningTimes is false.
+ *
+ * @param {Object} data - The restaurant data object containing settings and table information.
+ * @param {string} dateStr - The date string in "YYYY-MM-DD" format.
+ * @param {Array} reservations - An array of reservation objects.
+ * @param {number} guests - The number of guests for the reservation.
+ * @param {string|null} selectedGiftcard - The selected giftcard (if any).
+ * @returns {boolean} - Returns true if the date passes all checks to be available.
+ */
+function isDateAvailableWithTableCheck(data, dateStr, reservations, guests, selectedGiftcard) {
+  // 0) Optionally filter by selected menu item's date range (only when normalOpeningTimes = false)
+  const currentItem = typeof window !== 'undefined' ? window.currentReservationTicketItem : null;
+  if (
+    currentItem &&
+    !currentItem.normalOpeningTimes
+  ) {
+    const dateM = moment.tz(dateStr, 'YYYY-MM-DD', TIMEZONE).startOf('day');
+    const startM = currentItem.filterStartDate
+      ? moment.tz(currentItem.filterStartDate, 'YYYY-MM-DD', TIMEZONE).startOf('day')
+      : null;
+    const endM = currentItem.filterEndDate
+      ? moment.tz(currentItem.filterEndDate, 'YYYY-MM-DD', TIMEZONE).endOf('day')
+      : null;
+
+    if (startM && dateM.isBefore(startM)) {
+      console.log(`Date ${dateStr} is before the allowed start ${currentItem.filterStartDate}`);
+      return false;
+    }
+    if (endM && dateM.isAfter(endM)) {
+      console.log(`Date ${dateStr} is after the allowed end ${currentItem.filterEndDate}`);
+      return false;
+    }
+  }
+
+  console.log(`\n===== Checking date availability for ${guests} guests on ${dateStr} =====`);
+  console.log('Restaurant data floors:', data.floors ? 'present' : 'missing');
+  console.log('Table settings:', JSON.stringify(data['table-settings'] || {}, null, 2));
+
+  // Calculate table assignment flag once to reduce redundant checks
+  const tableSettings = data?.['table-settings'] || {};
+  const isTableAssignmentEnabled =
+    tableSettings.isInstalled === true &&
+    tableSettings.assignmentMode === 'automatic' &&
+    data.floors &&
+    Array.isArray(data.floors);
+
+  console.log(`Table assignment is ${isTableAssignmentEnabled ? 'ENABLED' : 'DISABLED'} for date ${dateStr}`);
+
+  // 1) First, do the standard day-level checks (including simple giftcard check).
+  const basicDateAvailable = isDateAvailable(data, dateStr, reservations, guests, selectedGiftcard);
+  if (!basicDateAvailable) {
+    console.log(`Date ${dateStr} fails basic availability check`);
+    return false;
+  }
+
+  // If table assignment is not enabled, stop here - the date is available
+  if (!isTableAssignmentEnabled) {
+    console.log(`Table assignment disabled, date ${dateStr} is available`);
+    return true;
+  }
+
+  // 2) Get all available timeblocks for this date
+  console.log(`Getting available timeblocks for ${dateStr}`);
+  const availableTimeblocks = getAvailableTimeblocks(data, dateStr, reservations, guests);
+  console.log(`Found ${Object.keys(availableTimeblocks).length} available timeblocks before table check`);
+
+  // If no timeblocks are available at all, exit early
+  if (Object.keys(availableTimeblocks).length === 0) {
+    console.log(`No available timeblocks on ${dateStr}, date is unavailable`);
+    return false;
+  }
+
+  // 3) Check if any timeblock has an available table and satisfies giftcard requirements
+  console.log(`Checking table availability for each timeblock on ${dateStr}`);
+
+  let atLeastOneAvailable = false;
+  let checkedCount = 0;
+
+  for (const time of Object.keys(availableTimeblocks)) {
+    checkedCount++;
+
+    // If there's a giftcard, confirm this particular time belongs to a meal that has that giftcard
+    if (selectedGiftcard && !timeHasGiftcard(data, dateStr, time, selectedGiftcard)) {
+      console.log(`Time ${time} doesn't match giftcard meal requirements`);
+      continue;
+    }
+
+    console.log(`Checking table availability for ${time} on ${dateStr} for ${guests} guests`);
+    if (isTimeAvailableSync(data, dateStr, time, guests, reservations)) {
+      console.log(`Found available time ${time} with table assignment!`);
+      atLeastOneAvailable = true;
+      break;
+    }
+  }
+
+  console.log(`Checked ${checkedCount}/${Object.keys(availableTimeblocks).length} timeblocks`);
+  console.log(`Date ${dateStr} with table check: ${atLeastOneAvailable ? 'Available' : 'Unavailable'}`);
+  
+  return atLeastOneAvailable;
+}
+
+module.exports = {
+  isDateAvailableWithTableCheck,
+};

package/isTimeAvailable.js

@@ -0,0 +1,22 @@
+const { timeblocksAvailable } = require('./processing/timeblocksAvailable');
+
+/**
+ * Checks if a given time (HH:MM) is available for a reservation.
+ * @param {Object} data - The main data object containing settings and opening hours.
+ * @param {string} dateStr - The date string in "YYYY-MM-DD" format.
+ * @param {string} timeStr - The time string in "HH:MM" format.
+ * @param {Array} reservations - An array of existing reservation objects.
+ * @param {number} guests - The number of guests for the new reservation request.
+ * @returns {boolean} - Returns true if the time is available, false otherwise.
+ */
+function isTimeAvailable(data, dateStr, timeStr, reservations, guests) {
+  // Get all available timeblocks for the specified date and guest count
+  const availableTimeblocks = timeblocksAvailable(data, dateStr, reservations, guests);
+
+  // Check if the specific timeStr is one of the available keys
+  return Object.prototype.hasOwnProperty.call(availableTimeblocks, timeStr);
+}
+
+module.exports = {
+  isTimeAvailable,
+};

package/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "@happychef/algorithm",
+  "version": "1.0.0",
+  "description": "Restaurant and reservation algorithm utilities",
+  "main": "index.js",
+  "author": "happy chef",
+  "license": "MIT",
+  "private": false,
+  "keywords": [
+    "algorithm",
+    "restaurant",
+    "reservation",
+    "utilities"
+  ],
+  "dependencies": {
+    "moment-timezone": "^0.6.0"
+  }
+}

package/processing/dailyGuestCounts.js

@@ -0,0 +1,73 @@
+// dailyGuestCounts.js
+
+const { getGuestCountsForMeal } = require('./mealTypeCount');
+
+/**
+ * Calculates guest counts for breakfast, lunch, and dinner, and combines the results into a flat object.
+ * If time slots overlap, the available seats from the latest meal (dinner > lunch > breakfast) are used.
+ * @param {Object} data - The main data object.
+ * @param {string} dateStr - The date string (YYYY-MM-DD).
+ * @param {Array} reservations - An array of reservation objects.
+ * @returns {Object} An object containing combined guest counts for all meals with time slots as keys,
+ *                   and an array of shiftsInfo containing shift details.
+ */
+function getDailyGuestCounts(data, dateStr, reservations) {
+  // Define meal types in order of priority (lowest to highest)
+  const mealTypes = ['breakfast', 'lunch', 'dinner'];
+  const combinedGuestCounts = {};
+  const shiftsInfo = [];
+  const mealPriority = {
+    'breakfast': 1,
+    'lunch': 2,
+    'dinner': 3
+  };
+
+  for (const mealType of mealTypes) {
+    const result = getGuestCountsForMeal(data, dateStr, mealType, reservations);
+    if (result) {
+      const { guestCounts, shiftsInfo: mealShiftsInfo } = result;
+
+      // Merge guestCounts into combinedGuestCounts
+      for (const [time, availableSeats] of Object.entries(guestCounts)) {
+        if (combinedGuestCounts.hasOwnProperty(time)) {
+          // Compare meal priorities
+          const existingMealPriority = combinedGuestCounts[time].mealPriority;
+          const currentMealPriority = mealPriority[mealType];
+
+          if (currentMealPriority >= existingMealPriority) {
+            // Update with the current meal's available seats and priority
+            combinedGuestCounts[time] = {
+              availableSeats,
+              mealPriority: currentMealPriority
+            };
+          }
+          // Else, keep the existing value
+        } else {
+          // Add new time slot with available seats and meal priority
+          combinedGuestCounts[time] = {
+            availableSeats,
+            mealPriority: mealPriority[mealType]
+          };
+        }
+      }
+
+      // Merge shiftsInfo
+      if (mealShiftsInfo && mealShiftsInfo.length > 0) {
+        shiftsInfo.push(...mealShiftsInfo);
+      }
+    }
+    // Else do nothing if the meal is not available
+  }
+
+  // Extract only the availableSeats for the final output
+  const finalGuestCounts = {};
+  for (const [time, data] of Object.entries(combinedGuestCounts)) {
+    finalGuestCounts[time] = data.availableSeats;
+  }
+
+  return { guestCounts: finalGuestCounts, shiftsInfo };
+}
+
+module.exports = {
+  getDailyGuestCounts,
+};

package/processing/mealTypeCount.js

@@ -0,0 +1,133 @@
+// mealTypeCount.js
+
+const { getDataByDateAndMealWithExceptions } = require('../restaurant_data/exceptions');
+const { parseTime } = require('../restaurant_data/openinghours');
+const { getGuestCountAtHour } = require('../reservation_data/counter');
+
+function getInterval(data) {
+  let intervalReservatie = 15;
+  if (
+    data['general-settings'] &&
+    data['general-settings'].intervalReservatie &&
+    parseInt(data['general-settings'].intervalReservatie, 10) > 0
+  ) {
+    intervalReservatie = parseInt(data['general-settings'].intervalReservatie, 10);
+  }
+  return intervalReservatie;
+}
+
+/**
+ * Retrieves meal types with shifts enabled and at least one shift defined for the specified date.
+ * @param {Object} data - The main data object.
+ * @param {string} dateStr - The date string (YYYY-MM-DD).
+ * @returns {Array} - An array of meal types with shifts.
+ */
+function getMealTypesWithShifts(data, dateStr) {
+  const mealTypes = ['breakfast', 'lunch', 'dinner'];
+  const mealTypesWithShifts = [];
+
+  for (const mealType of mealTypes) {
+    const mealData = getDataByDateAndMealWithExceptions(data, dateStr, mealType);
+    if (
+      mealData &&
+      mealData.shiftsEnabled &&
+      Array.isArray(mealData.shifts) &&
+      mealData.shifts.length > 0
+    ) {
+      mealTypesWithShifts.push(mealType);
+    }
+  }
+
+  return mealTypesWithShifts;
+}
+
+function shouldIncludeEndTime(mealType, endTime) {  
+  if ((mealType === 'breakfast' && endTime === '11:00') ||
+      (mealType === 'lunch' && endTime === '16:00')) {
+    return false; // Do not include endTime for breakfast at 11:00 and lunch at 16:00
+  }
+  return true; // Include endTime for all other cases
+}
+
+/**
+ * Calculates guest counts for each interval during a meal period or at shift times.
+ * @param {Object} data - The main data object.
+ * @param {string} dateStr - The date string (YYYY-MM-DD).
+ * @param {string} mealType - The meal type ("breakfast", "lunch", "dinner").
+ * @param {Array} reservations - An array of reservation objects.
+ * @returns {Object|null} An object mapping times to guest counts, or null if meal is not available.
+ */
+function getGuestCountsForMeal(data, dateStr, mealType, reservations) {
+  const mealData = getDataByDateAndMealWithExceptions(data, dateStr, mealType);
+  if (!mealData) {
+    return null;
+  }
+
+  const guestCounts = {};
+  const shiftsInfo = [];
+
+  // Get 'intervalReservatie' from general settings, default to 15 if not set or zero
+  let intervalReservatie = getInterval(data);
+
+  // Check if shifts are enabled and shifts array has valid content
+  if (
+    mealData.shiftsEnabled &&
+    Array.isArray(mealData.shifts) &&
+    mealData.shifts.length > 0
+  ) {
+    // If shifts are enabled and valid, calculate guest counts at shift times
+    const shifts = mealData.shifts; // Array of shifts
+
+    for (const shift of shifts) {
+      const timeStr = shift.time; // Time of the shift in "HH:MM" format
+
+      // Get guest count at this time
+      const guestCount = getGuestCountAtHour(data, reservations, timeStr, dateStr);
+
+      // Store in guestCounts
+      guestCounts[timeStr] = mealData.maxCapacity - guestCount;
+
+      // Store shift information
+      shiftsInfo.push({
+        mealType,
+        shiftName: shift.name,
+        time: timeStr,
+        availableSeats: mealData.maxCapacity - guestCount,
+      });
+    }
+  } else {
+    // If shifts are not enabled or shifts array is empty/invalid, calculate guest counts at intervals
+    const startTime = mealData.startTime;
+    const endTime = mealData.endTime;
+
+    // Determine if endTime should be included
+    const includeEndTime = shouldIncludeEndTime(mealType, endTime);
+
+    // Convert startTime and endTime to minutes since midnight
+    let currentTime = parseTime(startTime);
+    const endTimeMinutes = parseTime(endTime);
+
+    while (includeEndTime ? currentTime <= endTimeMinutes : currentTime < endTimeMinutes) {
+      // Convert currentTime back to "HH:MM" format
+      const hours = Math.floor(currentTime / 60).toString().padStart(2, '0');
+      const minutes = (currentTime % 60).toString().padStart(2, '0');
+      const timeStr = `${hours}:${minutes}`;
+
+      // Get guest count at this time
+      const guestCount = getGuestCountAtHour(data, reservations, timeStr, dateStr);
+
+      // Store in guestCounts
+      guestCounts[timeStr] = mealData.maxCapacity - guestCount;
+
+      // Increment currentTime by 'intervalReservatie' minutes
+      currentTime += intervalReservatie;
+    }
+  }
+
+  return { guestCounts, shiftsInfo };
+}
+
+module.exports = {
+  getGuestCountsForMeal,
+  getMealTypesWithShifts, // Exported
+};

package/processing/timeblocksAvailable.js

@@ -0,0 +1,120 @@
+const { getDailyGuestCounts } = require('./dailyGuestCounts');
+const { getMealTypesWithShifts } = require('./mealTypeCount');
+const { getDataByDateAndMealWithExceptions } = require('../restaurant_data/exceptions');
+const { getMealTypeByTime, parseTime: parseTimeOH } = require('../restaurant_data/openinghours');
+
+/**
+ * Parses a time string in "HH:MM" format into minutes since midnight.
+ */
+function parseTime(timeStr) {
+  const [hours, minutes] = timeStr.split(':').map(Number);
+  return hours * 60 + minutes;
+}
+
+/**
+ * Retrieves interval and duurReservatie from general settings
+ */
+function getInterval(data) {
+  let intervalReservatie = 15;
+  if (
+    data['general-settings'] &&
+    data['general-settings'].intervalReservatie &&
+    parseInt(data['general-settings'].intervalReservatie, 10) > 0
+  ) {
+    intervalReservatie = parseInt(data['general-settings'].intervalReservatie, 10);
+  }
+  return intervalReservatie;
+}
+
+function getDuurReservatie(data) {
+  let duurReservatie = 120;
+  if (
+    data['general-settings'] &&
+    data['general-settings'].duurReservatie &&
+    parseInt(data['general-settings'].duurReservatie, 10) > 0
+  ) {
+    duurReservatie = parseInt(data['general-settings'].duurReservatie, 10);
+  }
+  return duurReservatie;
+}
+
+/**
+ * Determines if a given start time plus duurReservatie fits within the meal timeframe.
+ */
+function fitsWithinMeal(data, dateStr, startTimeStr, duurReservatie) {
+  // Determine the meal type based on the start time
+  const mealType = getMealTypeByTime(startTimeStr);
+  if (!mealType) return false;
+
+  // Get the meal data (with exceptions applied)
+  const mealData = getDataByDateAndMealWithExceptions(data, dateStr, mealType);
+  if (!mealData) return false;
+
+  const mealStartTime = parseTime(mealData.startTime);
+  const mealEndTime = parseTime(mealData.endTime);
+  const startTime = parseTime(startTimeStr);
+  
+  // Check if startTime is after or equal to mealStartTime AND startTime + duurReservatie is within the mealEndTime
+  return startTime >= mealStartTime && startTime + duurReservatie <= mealEndTime;
+}
+
+function timeblocksAvailable(data, dateStr, reservations, guests) {
+  const duurReservatie = getDuurReservatie(data);
+  const intervalReservatie = getInterval(data);
+
+  // Slots needed
+  const slotsNeeded = Math.ceil(duurReservatie / intervalReservatie);
+
+  // Get guest counts and shifts info
+  const { guestCounts, shiftsInfo } = getDailyGuestCounts(data, dateStr, reservations);
+
+  const availableTimeblocks = {};
+
+  // Handle shifts first
+  const mealTypesWithShifts = getMealTypesWithShifts(data, dateStr);
+  if (mealTypesWithShifts.length > 0 && shiftsInfo && shiftsInfo.length > 0) {
+    for (const shift of shiftsInfo) {
+      const { time, availableSeats } = shift;
+      if (availableSeats >= guests && fitsWithinMeal(data, dateStr, time, duurReservatie)) {
+        availableTimeblocks[time] = { name: time };
+      }
+    }
+  }
+
+  // Handle non-shift times
+  if (guestCounts && Object.keys(guestCounts).length > 0) {
+    const timeSlots = Object.keys(guestCounts).sort((a, b) => parseTime(a) - parseTime(b));
+
+    for (let i = 0; i <= timeSlots.length - slotsNeeded; i++) {
+      // Check capacity for all needed slots
+      let consecutiveSlotsAvailable = true;
+      if (guestCounts[timeSlots[i]] < guests) {
+        continue;
+      }
+
+      let previousTime = parseTime(timeSlots[i]);
+      for (let j = 1; j < slotsNeeded; j++) {
+        const currentTimeSlot = timeSlots[i + j];
+        const currentTime = parseTime(currentTimeSlot);
+
+        // Check interval and capacity
+        if ((currentTime - previousTime) !== intervalReservatie || guestCounts[currentTimeSlot] < guests) {
+          consecutiveSlotsAvailable = false;
+          break;
+        }
+        previousTime = currentTime;
+      }
+
+      // If all consecutive slots are available, check if the full duration fits
+      if (consecutiveSlotsAvailable && fitsWithinMeal(data, dateStr, timeSlots[i], duurReservatie)) {
+        availableTimeblocks[timeSlots[i]] = { name: timeSlots[i] };
+      }
+    }
+  }
+
+  return availableTimeblocks;
+}
+
+module.exports = {
+  timeblocksAvailable,
+};

package/reservation_data/counter.js

@@ -0,0 +1,65 @@
+// counter.js
+
+/**
+ * Parses a time string in "HH:MM" format into minutes since midnight.
+ * @param {string} timeStr - The time string in "HH:MM" format.
+ * @returns {number} The time in minutes since midnight.
+ */
+function parseTime(timeStr) {
+	const [hours, minutes] = timeStr.split(':').map(Number);
+	return hours * 60 + minutes;
+  }
+
+  function getDuurReservatie(data) {
+	let duurReservatie = 120;
+	if (
+	  data['general-settings'] &&
+	  data['general-settings'].duurReservatie &&
+	  parseInt(data['general-settings'].duurReservatie, 10) > 0
+	) {
+	  duurReservatie = parseInt(data['general-settings'].duurReservatie, 10);
+	}
+
+	return duurReservatie;
+  }
+  
+  /**
+   * Calculates the total number of guests for reservations that cover a specific hour on a specific date.
+   * @param {Object} data - The main data object containing general settings.
+   * @param {Array} reservations - An array of reservation objects.
+   * @param {string} hour - The hour to check in "HH:MM" format.
+   * @param {string} dateStr - The date string in "YYYY-MM-DD" format.
+   * @returns {number} The total number of guests for that hour on the specified date.
+   */
+  function getGuestCountAtHour(data, reservations, hour, dateStr) {
+	// Get 'duurReservatie' from general settings, default to 120 if not set or zero
+	let duurReservatie = getDuurReservatie(data)
+  
+	// Convert the target hour to minutes since midnight
+	const targetTime = parseTime(hour);
+  
+	let totalGuests = 0;
+  
+	for (const reservation of reservations) {
+	  // Only consider reservations on the specified date
+	  if (reservation.date !== dateStr) {
+		continue;
+	  }
+  
+	  const startTime = parseTime(reservation.time);
+
+	  const endTime = startTime + duurReservatie; // Use 'duurReservatie' from general settings
+  	  // Check if the target time is within the reservation time range
+	  // Start time is inclusive, end time is exclusive
+	  if (targetTime >= startTime && targetTime < endTime) {
+		totalGuests += parseInt(reservation.guests, 10);
+	  }
+	}
+  
+	return totalGuests;
+  }
+  
+  module.exports = {
+	getGuestCountAtHour,
+  };
+