@happychef/algorithm 1.3.2 → 1.4.0

package/processing/timeblocksAvailable.js

@@ -1,183 +1,345 @@
-const { getDailyGuestCounts } = require('./dailyGuestCounts');
-const { getMealTypesWithShifts } = require('./mealTypeCount');
-const { getDataByDateAndMealWithExceptions } = require('../restaurant_data/exceptions');
-const { getMealTypeByTime, parseTime: parseTimeOH, daysOfWeekEnglish } = require('../restaurant_data/openinghours');
-const moment = require('moment-timezone');
-
-/**
- * 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;
-}
-
-/**
- * Checks if a time slot belongs to a meal that has the selected giftcard enabled.
- */
-function timeHasGiftcard(data, dateStr, timeStr, giftcard) {
-  if (!giftcard || (typeof giftcard === 'string' && !giftcard.trim())) {
-    return true; // No giftcard => no restriction
-  }
-
-  const mealType = getMealTypeByTime(timeStr);
-  if (!mealType) return false;
-
-  const m = moment.tz(dateStr, 'YYYY-MM-DD', 'Europe/Brussels');
-  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) return false;
-  if (daySettings.giftcardsEnabled !== true) return false;
-  if (!Array.isArray(daySettings.giftcards) || daySettings.giftcards.length === 0) return false;
-
-  return daySettings.giftcards.includes(giftcard);
-}
-
-/**
- * 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, blockedSlots = [], giftcard = null, isAdmin = false, duration = null) {
-  const duurReservatie = duration && duration > 0 ? duration : 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)) {
-        // Check if time matches giftcard requirement
-        if (timeHasGiftcard(data, dateStr, time, giftcard)) {
-          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)) {
-        // Check if time matches giftcard requirement
-        if (timeHasGiftcard(data, dateStr, timeSlots[i], giftcard)) {
-          availableTimeblocks[timeSlots[i]] = { name: timeSlots[i] };
-        }
-      }
-    }
-  }
-
-  // Filter out blocked time slots (skip for admin)
-  if (!isAdmin && blockedSlots && blockedSlots.length > 0) {
-    // Check if waitlist is enabled in settings (default to true if not defined)
-    // The setting key is 'waitlistEnabled' in 'general-settings'
-    const settings = data['general-settings'] || {};
-    const waitlistEnabled = settings.waitlistEnabled !== undefined ? settings.waitlistEnabled === true : true;
-
-    for (const blockedSlot of blockedSlots) {
-      // Check if the blocked slot matches the current date
-      if (blockedSlot.date === dateStr && blockedSlot.time) {
-        if (waitlistEnabled) {
-          // If waitlist is enabled, mark it as a waitlist item instead of deleting
-          // We force it into the list even if it wasn't there (e.g. if it was full)
-          // because a manual block + waitlist implies we want to capture interest for this specific blocked time.
-          availableTimeblocks[blockedSlot.time] = { 
-            name: blockedSlot.time,
-            isWaitlist: true 
-          };
-        } else {
-          // Default behavior: Remove the blocked time from available timeblocks
-          delete availableTimeblocks[blockedSlot.time];
-        }
-      }
-    }
-  }
-
-  return availableTimeblocks;
-}
-
-module.exports = {
-  timeblocksAvailable,
+const { getDailyGuestCounts } = require('./dailyGuestCounts');
+const { getMealTypesWithShifts } = require('./mealTypeCount');
+const { getDataByDateAndMealWithExceptions } = require('../restaurant_data/exceptions');
+const { getMealTypeByTime, daysOfWeekEnglish } = require('../restaurant_data/openinghours');
+const { getGuestCountAtHour } = require('../reservation_data/counter');
+const { getNextDateStr } = require('../dateHelpers');
+const moment = require('moment-timezone');
+
+/**
+ * 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;
+}
+
+function getHoursOpenedPastMidnight(data, dateStr) {
+  // Per-day value from dinner opening hours
+  const m = moment.tz(dateStr, 'YYYY-MM-DD', 'Europe/Brussels');
+  if (m.isValid()) {
+    const day = daysOfWeekEnglish[m.day()];
+    const dinnerSettings = data['openinghours-dinner']?.schemeSettings?.[day];
+    if (dinnerSettings?.hoursOpenedPastMidnight !== undefined) {
+      const parsed = parseInt(dinnerSettings.hoursOpenedPastMidnight, 10);
+      return (!isNaN(parsed) && parsed > 0) ? parsed : 0;
+    }
+  }
+  // Fallback: global setting from general-settings (backward compat)
+  const val = data['general-settings']?.hoursOpenedPastMidnight;
+  const parsed = parseInt(val, 10);
+  return (!isNaN(parsed) && parsed > 0) ? parsed : 0;
+}
+
+/**
+ * Checks if hoursOpenedPastMidnight is explicitly defined in settings.
+ * Used to distinguish bowling restaurants (who set it) from regular ones (who don't).
+ */
+function hasMidnightSetting(data, dateStr) {
+  const m = moment.tz(dateStr, 'YYYY-MM-DD', 'Europe/Brussels');
+  if (m.isValid()) {
+    const day = daysOfWeekEnglish[m.day()];
+    const dinnerSettings = data['openinghours-dinner']?.schemeSettings?.[day];
+    if (dinnerSettings?.hoursOpenedPastMidnight !== undefined) return true;
+  }
+  const val = data['general-settings']?.hoursOpenedPastMidnight;
+  return val !== undefined && val !== null;
+}
+
+/**
+ * Checks if a time slot belongs to a meal that has the selected giftcard enabled.
+ */
+function timeHasGiftcard(data, dateStr, timeStr, giftcard) {
+  if (!giftcard || (typeof giftcard === 'string' && !giftcard.trim())) {
+    return true; // No giftcard => no restriction
+  }
+
+  const mealType = getMealTypeByTime(timeStr);
+  if (!mealType) return false;
+
+  const m = moment.tz(dateStr, 'YYYY-MM-DD', 'Europe/Brussels');
+  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) return false;
+  if (daySettings.giftcardsEnabled !== true) return false;
+  if (!Array.isArray(daySettings.giftcards) || daySettings.giftcards.length === 0) return false;
+
+  return daySettings.giftcards.includes(giftcard);
+}
+
+/**
+ * Determines if a given start time fits within any meal's timeframe.
+ * For bowling restaurants (hasMidnightSetting), the extended endTime is used so that
+ * slots like 23:15, 24:00 are valid start times.
+ * For regular restaurants, uses the original production logic:
+ *   startTime + duurReservatie <= mealEndTime
+ * which naturally caps the last bookable slot (e.g. 22:45 for 23:00 close + 15min interval).
+ */
+function fitsWithinMeal(data, dateStr, startTimeStr, duurReservatie) {
+  const startTime = parseTime(startTimeStr);
+
+  // Original production logic for breakfast/lunch (always, regardless of bowling)
+  const mealType = getMealTypeByTime(startTimeStr);
+  if (mealType === 'breakfast' || mealType === 'lunch') {
+    const mealData = getDataByDateAndMealWithExceptions(data, dateStr, mealType);
+    if (!mealData) return false;
+    const mealStartTime = parseTime(mealData.startTime);
+    const mealEndTime = parseTime(mealData.endTime);
+    return startTime >= mealStartTime && startTime + duurReservatie <= mealEndTime;
+  }
+
+  if (hasMidnightSetting(data, dateStr)) {
+    // Bowling dinner: allow start times up to extended endTime (e.g. 24:00)
+    const dinnerData = getDataByDateAndMealWithExceptions(data, dateStr, 'dinner');
+    if (!dinnerData) return false;
+    const dinnerStart = parseTime(dinnerData.startTime);
+    const dinnerEnd = parseTime(dinnerData.endTime);
+    return startTime >= dinnerStart && startTime <= dinnerEnd;
+  }
+
+  // Regular restaurant dinner: original production logic
+  if (!mealType) return false;
+  const mealData = getDataByDateAndMealWithExceptions(data, dateStr, mealType);
+  if (!mealData) return false;
+  const mealStartTime = parseTime(mealData.startTime);
+  const mealEndTime = parseTime(mealData.endTime);
+  return startTime >= mealStartTime && startTime + duurReservatie <= mealEndTime;
+}
+
+/**
+ * Converts minutes since midnight to "HH:MM" string.
+ */
+function minutesToTimeStr(minutes) {
+  const h = Math.floor(minutes / 60);
+  const m = minutes % 60;
+  return `${String(h).padStart(2, '0')}:${String(m).padStart(2, '0')}`;
+}
+
+/**
+ * Gets the max capacity for a time on a given date by checking all meals.
+ * Returns 0 if no meal covers the time (restaurant is closed at that time).
+ */
+function getMaxCapacityForTime(data, dateStr, timeMinutes) {
+  for (const mealType of ['breakfast', 'lunch', 'dinner']) {
+    const mealData = getDataByDateAndMealWithExceptions(data, dateStr, mealType);
+    if (!mealData) continue;
+    const mealStart = parseTime(mealData.startTime);
+    const mealEnd = parseTime(mealData.endTime);
+    if (timeMinutes >= mealStart && timeMinutes <= mealEnd) {
+      return parseInt(mealData.maxCapacity, 10) || 0;
+    }
+  }
+  return 0;
+}
+
+function timeblocksAvailable(data, dateStr, reservations, guests, blockedSlots = [], giftcard = null, isAdmin = false, duration = null) {
+  const defaultDuurReservatie = getDuurReservatie(data);
+  const duurReservatie = duration && duration > 0 ? duration : defaultDuurReservatie;
+  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);
+
+  // If custom duration exceeds default, extend guestCounts with additional slots
+  // so that late-evening reservations have enough consecutive slots to check against.
+  const hoursOpenedPastMidnight = getHoursOpenedPastMidnight(data, dateStr);
+  if (duurReservatie > defaultDuurReservatie && guestCounts && Object.keys(guestCounts).length > 0) {
+    const existingSlots = Object.keys(guestCounts).map(parseTime);
+    const maxExistingSlot = Math.max(...existingSlots);
+    const extraMinutes = duurReservatie - defaultDuurReservatie;
+    const extendedEnd = maxExistingSlot + extraMinutes;
+
+    // Find the last meal's maxCapacity for use with spillover slots
+    const lastMealMaxCap = getMaxCapacityForTime(data, dateStr, maxExistingSlot);
+
+    for (let t = maxExistingSlot + intervalReservatie; t <= extendedEnd; t += intervalReservatie) {
+      const timeStr = minutesToTimeStr(t);
+      if (!(timeStr in guestCounts)) {
+        if (t >= 1440) {
+          // Cross-midnight slot: use hoursOpenedPastMidnight limit and last meal's capacity
+          const spilloverMinutes = t - 1440;
+          if (hoursOpenedPastMidnight > 0 && spilloverMinutes < hoursOpenedPastMidnight * 60) {
+            const gc = getGuestCountAtHour(data, reservations, minutesToTimeStr(spilloverMinutes), getNextDateStr(dateStr));
+            if (lastMealMaxCap > 0) {
+              guestCounts[timeStr] = lastMealMaxCap - gc;
+            }
+          }
+        } else {
+          // Same-day extended slot
+          const gc = getGuestCountAtHour(data, reservations, timeStr, dateStr);
+          const maxCap = getMaxCapacityForTime(data, dateStr, t);
+          if (maxCap > 0) {
+            guestCounts[timeStr] = maxCap - gc;
+          }
+        }
+      }
+    }
+  }
+
+  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)) {
+        // Check if time matches giftcard requirement
+        if (timeHasGiftcard(data, dateStr, time, giftcard)) {
+          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; i++) {
+      // Check capacity for the first slot
+      if (guestCounts[timeSlots[i]] < guests) {
+        continue;
+      }
+
+      const startMinutes = parseTime(timeSlots[i]);
+      let consecutiveSlotsAvailable = true;
+
+      for (let j = 1; j < slotsNeeded; j++) {
+        const neededMinutes = startMinutes + j * intervalReservatie;
+
+        // First try same-day check from guestCounts.
+        // This handles both regular times AND extended meal times (e.g. "24:00", "24:30")
+        // produced by addDuurReservatieToEndTime. Without this, regular restaurants would
+        // break near midnight because the cross-midnight branch rejects when hoursOpenedPastMidnight=0.
+        const slotIndex = i + j;
+        if (slotIndex < timeSlots.length) {
+          const currentTimeSlot = timeSlots[slotIndex];
+          const currentTime = parseTime(currentTimeSlot);
+          if (currentTime === neededMinutes) {
+            if (guestCounts[currentTimeSlot] < guests) {
+              consecutiveSlotsAvailable = false;
+              break;
+            }
+            continue; // Slot available via guestCounts
+          }
+        }
+
+        // Slot not found in guestCounts — check cross-midnight if applicable
+        if (neededMinutes >= 1440) {
+          if (hoursOpenedPastMidnight <= 0) {
+            consecutiveSlotsAvailable = false;
+            break;
+          }
+          const spilloverMinutes = neededMinutes - 1440;
+          if (spilloverMinutes >= hoursOpenedPastMidnight * 60) {
+            consecutiveSlotsAvailable = false;
+            break;
+          }
+          // Use starting meal's capacity as limit for spillover period
+          const nextDateStr = getNextDateStr(dateStr);
+          const nextTimeStr = minutesToTimeStr(spilloverMinutes);
+          const nextDayGuestCount = getGuestCountAtHour(data, reservations, nextTimeStr, nextDateStr);
+          const startMealCap = getMaxCapacityForTime(data, dateStr, startMinutes);
+          if (startMealCap - nextDayGuestCount < guests) {
+            consecutiveSlotsAvailable = false;
+            break;
+          }
+          continue; // Cross-midnight slot OK
+        }
+
+        // Not in guestCounts and not cross-midnight — gap in availability
+        consecutiveSlotsAvailable = false;
+        break;
+      }
+
+      // If the reservation would end past midnight, enforce hoursOpenedPastMidnight limit
+      // Only applies when the setting is explicitly defined (bowling restaurants).
+      if (consecutiveSlotsAvailable && hasMidnightSetting(data, dateStr)) {
+        const endMinutes = startMinutes + duurReservatie;
+        if (endMinutes > 1440 + hoursOpenedPastMidnight * 60) {
+          consecutiveSlotsAvailable = false;
+        }
+      }
+
+      // If all consecutive slots are available, check if the start time fits within a meal
+      if (consecutiveSlotsAvailable && fitsWithinMeal(data, dateStr, timeSlots[i], duurReservatie)) {
+        // Check if time matches giftcard requirement
+        if (timeHasGiftcard(data, dateStr, timeSlots[i], giftcard)) {
+          availableTimeblocks[timeSlots[i]] = { name: timeSlots[i] };
+        }
+      }
+    }
+  }
+
+  // Filter out blocked time slots (skip for admin)
+  if (!isAdmin && blockedSlots && blockedSlots.length > 0) {
+    // Check if waitlist is enabled in settings (default to true if not defined)
+    // The setting key is 'waitlistEnabled' in 'general-settings'
+    const settings = data['general-settings'] || {};
+    const waitlistEnabled = settings.waitlistEnabled !== undefined ? settings.waitlistEnabled === true : true;
+
+    for (const blockedSlot of blockedSlots) {
+      // Check if the blocked slot matches the current date
+      if (blockedSlot.date === dateStr && blockedSlot.time) {
+        if (waitlistEnabled) {
+          // If waitlist is enabled, mark it as a waitlist item instead of deleting
+          // We force it into the list even if it wasn't there (e.g. if it was full)
+          // because a manual block + waitlist implies we want to capture interest for this specific blocked time.
+          availableTimeblocks[blockedSlot.time] = { 
+            name: blockedSlot.time,
+            isWaitlist: true 
+          };
+        } else {
+          // Default behavior: Remove the blocked time from available timeblocks
+          delete availableTimeblocks[blockedSlot.time];
+        }
+      }
+    }
+  }
+
+  return availableTimeblocks;
+}
+
+module.exports = {
+  timeblocksAvailable,
 };