@happychef/algorithm 1.2.5 → 1.2.7

package/filters/maxArrivalsFilter.js

@@ -49,16 +49,16 @@ function getMealType(time) {
   }
   
   /**
-   * Count number of groups/reservations arriving at exact time
+   * Count guests arriving at exact time
    * @param {Array} reservations - Reservation list
    * @param {string} date - Date (YYYY-MM-DD)
    * @param {string} time - Time (HH:MM)
-   * @returns {number} - Number of groups/arrivals (count of reservations)
+   * @returns {number} - Guest count
    */
   function countArrivalsAtTime(reservations, date, time) {
 	return reservations
 	  .filter(r => r.date === date && r.time === time)
-	  .length; // Count number of reservations, not total guests
+	  .reduce((sum, r) => sum + (parseInt(r.guests, 10) || 0), 0);
   }
   
   /**
@@ -92,18 +92,17 @@ function getMealType(time) {
 	  
 	  // Get max arrivals value for this specific time
 	  const maxArrivals = extractNumber(maxArrivalsConfig[time]);
-	  if (maxArrivals === null || maxArrivals <= 0) {
-		// Keep the timeblock if no specific max arrivals for this time, or if set to 0 (unlimited)
+	  if (maxArrivals === null) {
+		// Keep the timeblock if no specific max arrivals for this time
 		filteredBlocks[time] = timeData;
 		continue;
 	  }
-
+	  
 	  // Count current arrivals at this exact time
 	  const currentArrivals = countArrivalsAtTime(reservations, date, time);
-
+	  
 	  // Only include timeblock if adding these guests doesn't exceed max arrivals
-	  // Note: maxArrivals is the number of GROUPS (arrivals), not guests
-	  if (currentArrivals + 1 <= maxArrivals) {
+	  if (currentArrivals + guests <= maxArrivals) {
 		filteredBlocks[time] = timeData;
 	  }
 	}

package/filters/maxGroupsFilter.js

@@ -166,11 +166,10 @@ function getMealType(time) {
 		  // Extract the maximum number of groups allowed for this threshold
 		  const maxAllowedCount = extractNumber(maxGroupSettings[limitSizeStr]);
 		  logDebug(`      Max groups allowed for >=${limitSize} is: ${maxAllowedCount} (raw setting: ${JSON.stringify(maxGroupSettings[limitSizeStr])})`);
-
-		  // If the setting for this limit size is invalid (null, zero, or negative), treat it as 'no limit'
-		  // IMPORTANT: A value of 0 means "unlimited" - don't apply this filter
-		  if (maxAllowedCount === null || maxAllowedCount <= 0) {
-			logDebug(`      Skipping check: Invalid or non-positive max count (${maxAllowedCount}) - treating as unlimited for size ${limitSize}.`);
+  
+		  // If the setting for this limit size is invalid (null or negative), treat it as 'no limit'
+		  if (maxAllowedCount === null || maxAllowedCount < 0) {
+			logDebug(`      Skipping check: Invalid or non-positive max count defined for size ${limitSize}.`);
 			continue; // Skip to the next limitSize
 		  }
   

package/getAvailableTimeblocks.js

@@ -1,27 +1,22 @@
 // getAvailableTimeblocks.js
 
 const { timeblocksAvailable } = require('./processing/timeblocksAvailable');
-const { filterTimeblocksByMaxArrivals } = require('./filters/maxArrivalsFilter');
-const { filterTimeblocksByMaxGroups } = require('./filters/maxGroupsFilter');
+const { parseTime, getMealTypeByTime } = require('./tableHelpers');
 
 /**
  * Parses a time string in "HH:MM" format into a Date object on a specific date.
  * @param {string} dateStr - The date string in "YYYY-MM-DD" format.
  * @param {string} timeStr - Time string in "HH:MM" format.
- * @param {string} timeZone - The IANA time zone identifier.
- * @returns {Date} Date object representing the time on the specified date and time zone.
+ * @param {string} timeZone - The IANA time zone identifier (not used, kept for compatibility).
+ * @returns {Date} Date object representing the time on the specified date.
  */
 function parseDateTimeInTimeZone(dateStr, timeStr, timeZone) {
   const [year, month, day] = dateStr.split('-').map(Number);
   const [hours, minutes] = timeStr.split(':').map(Number);
 
-  // Create a date object in UTC
-  const date = new Date(Date.UTC(year, month - 1, day, hours, minutes));
-  // Convert that UTC date/time to the specified time zone
-  const dateInTimeZone = new Date(
-    date.toLocaleString('en-US', { timeZone: timeZone })
-  );
-  return dateInTimeZone;
+  // Create a simple date object for the given date and time
+  // This represents the local time on that date
+  return new Date(year, month - 1, day, hours, minutes);
 }
 
 /**
@@ -59,23 +54,19 @@ function getAvailableTimeblocks(data, dateStr, reservations, guests, blockedSlot
   // Time zone for CEST/CET (Europe/Amsterdam)
   const timeZone = 'Europe/Amsterdam';
 
-  // Current date/time in CEST
+  // Current date/time in local timezone (system time)
+  // Note: We assume the server is running in the correct timezone
   const now = new Date();
-  const currentTimeInTimeZone = new Date(
-    now.toLocaleString('en-US', { timeZone: timeZone })
-  );
+  const currentTimeInTimeZone = now;
 
   // Calculate the maximum allowed date
   const maxAllowedDate = new Date(currentTimeInTimeZone.getTime());
   maxAllowedDate.setDate(maxAllowedDate.getDate() + dagenInToekomst);
   maxAllowedDate.setHours(23, 59, 59, 999);
 
-  // Parse the target date in the specified time zone
+  // Parse the target date (just the date part, no time)
   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 })
-  );
+  const targetDateInTimeZone = new Date(year, month - 1, day);
 
   // Check if targetDateInTimeZone is within dagenInToekomst (skip for admin)
   if (!isAdmin && targetDateInTimeZone > maxAllowedDate) {
@@ -88,7 +79,7 @@ function getAvailableTimeblocks(data, dateStr, reservations, guests, blockedSlot
     currentTimeInTimeZone.toDateString() === targetDateInTimeZone.toDateString();
 
   // Get available time blocks or shifts
-  let availableTimeblocks = timeblocksAvailable(data, dateStr, reservations, guests, blockedSlots, giftcard, isAdmin);
+  const availableTimeblocks = timeblocksAvailable(data, dateStr, reservations, guests, blockedSlots, giftcard, isAdmin);
 
   // If the date is today and uurOpVoorhand is greater than zero, prune time blocks (skip for admin)
   if (!isAdmin && isToday && uurOpVoorhand >= 0) {
@@ -106,14 +97,45 @@ function getAvailableTimeblocks(data, dateStr, reservations, guests, blockedSlot
     }
   }
 
-  // Apply max arrivals filter (skip for admin)
-  if (!isAdmin) {
-    availableTimeblocks = filterTimeblocksByMaxArrivals(data, dateStr, availableTimeblocks, reservations, guests);
-  }
-
-  // Apply max groups filter (skip for admin)
-  if (!isAdmin) {
-    availableTimeblocks = filterTimeblocksByMaxGroups(data, dateStr, availableTimeblocks, reservations, guests);
+  // Apply last booking time filter (lunchStop, dinerStop, ontbijtStop) - skip for admin
+  // IMPORTANT: This filter should only apply to TODAY, just like uurOpVoorhand
+  if (!isAdmin && isToday) {
+    const settings = data?.['general-settings'] || {};
+    const breakfastStop = settings.ontbijtStop || null;
+    const lunchStop = settings.lunchStop || null;
+    const dinnerStop = settings.dinerStop || null;
+
+    // Only apply if at least one stop time is configured
+    if (breakfastStop || lunchStop || dinnerStop) {
+      for (const time in availableTimeblocks) {
+        const mealType = getMealTypeByTime(time);
+        const timeMinutes = parseTime(time);
+        let shouldRemove = false;
+
+        // Check if this time is AT OR AFTER the stop time for its meal type
+        // Using ">=" so that lunchStop="14:00" blocks 14:00 and later times
+        if (mealType === 'breakfast' && breakfastStop) {
+          const stopMinutes = parseTime(breakfastStop);
+          if (timeMinutes >= stopMinutes) {
+            shouldRemove = true;
+          }
+        } else if (mealType === 'lunch' && lunchStop) {
+          const stopMinutes = parseTime(lunchStop);
+          if (timeMinutes >= stopMinutes) {
+            shouldRemove = true;
+          }
+        } else if (mealType === 'dinner' && dinnerStop) {
+          const stopMinutes = parseTime(dinnerStop);
+          if (timeMinutes >= stopMinutes) {
+            shouldRemove = true;
+          }
+        }
+
+        if (shouldRemove) {
+          delete availableTimeblocks[time];
+        }
+      }
+    }
   }
 
   return availableTimeblocks;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@happychef/algorithm",
-  "version": "1.2.5",
+  "version": "1.2.7",
   "description": "Restaurant and reservation algorithm utilities",
   "main": "index.js",
   "author": "happy chef",

package/test-detailed-filter.js

@@ -0,0 +1,100 @@
+// Detailed filter test - simulating getAvailableTimeblocks logic
+const { timeblocksAvailable } = require('./processing/timeblocksAvailable');
+const { getMealTypeByTime, parseTime } = require('./tableHelpers');
+
+const restaurantData = {
+  "_id": "demo",
+  "openinghours-lunch": {
+    "schemeSettings": {
+      "Monday": {
+        "enabled": true,
+        "startTime": "14:15",
+        "endTime": "15:00",
+        "maxCapacityEnabled": true,
+        "maxCapacity": "10"
+      }
+    }
+  },
+  "general-settings": {
+    "zitplaatsen": 13,
+    "uurOpVoorhand": 0,
+    "dagenInToekomst": 365,
+    "intervalReservatie": 30,
+    "duurReservatie": 60,
+    "ontbijtStop": "",
+    "lunchStop": "",
+    "dinerStop": ""
+  },
+  "max-arrivals-lunch": {
+    "14:15": 10,
+    "14:30": 10,
+    "14:45": 10
+  }
+};
+
+const testDate = "2025-12-08";
+const guests = 2;
+const reservations = [];
+const uurOpVoorhand = 0;
+const isAdmin = false;
+
+console.log('=== DETAILED FILTER TEST ===\n');
+
+// Get timeblocks
+const availableTimeblocks = timeblocksAvailable(restaurantData, testDate, reservations, guests, [], null, isAdmin);
+console.log('Initial timeblocks:', Object.keys(availableTimeblocks));
+
+// Simulate the time filtering logic
+const now = new Date();
+const [year, month, day] = testDate.split('-').map(Number);
+const targetDateInTimeZone = new Date(year, month - 1, day);
+const isToday = now.toDateString() === targetDateInTimeZone.toDateString();
+
+console.log('\nTime filter check:');
+console.log('Is today:', isToday);
+console.log('uurOpVoorhand:', uurOpVoorhand);
+console.log('Current time:', now.toString());
+
+if (isToday && uurOpVoorhand >= 0) {
+  const cutoffTime = new Date(now.getTime());
+  cutoffTime.setHours(cutoffTime.getHours() + uurOpVoorhand);
+  console.log('Cutoff time:', cutoffTime.toString());
+
+  for (const key of Object.keys(availableTimeblocks)) {
+    const timeStr = key;
+    const [hours, minutes] = timeStr.split(':').map(Number);
+    const timeBlockDateTime = new Date(year, month - 1, day, hours, minutes);
+
+    console.log(`\n  Checking ${timeStr}:`);
+    console.log(`    timeBlockDateTime: ${timeBlockDateTime.toString()}`);
+    console.log(`    cutoffTime: ${cutoffTime.toString()}`);
+    console.log(`    timeBlockDateTime < cutoffTime: ${timeBlockDateTime < cutoffTime}`);
+    console.log(`    Would be deleted: ${timeBlockDateTime < cutoffTime ? 'YES' : 'NO'}`);
+  }
+}
+
+// Check lunchStop filter
+console.log('\n\nLunch Stop filter check:');
+const settings = restaurantData['general-settings'];
+const lunchStop = settings.lunchStop || null;
+console.log('lunchStop value:', JSON.stringify(lunchStop));
+console.log('lunchStop truthy:', !!lunchStop);
+
+if (lunchStop) {
+  console.log('LunchStop is set, would apply filter');
+  for (const time in availableTimeblocks) {
+    const mealType = getMealTypeByTime(time);
+    console.log(`  ${time}: mealType=${mealType}`);
+
+    if (mealType === 'lunch') {
+      const timeMinutes = parseTime(time);
+      const stopMinutes = parseTime(lunchStop);
+      console.log(`    timeMinutes=${timeMinutes}, stopMinutes=${stopMinutes}`);
+      console.log(`    Would remove: ${timeMinutes >= stopMinutes ? 'YES' : 'NO'}`);
+    }
+  }
+} else {
+  console.log('LunchStop is NOT set, no filter applied');
+}
+
+console.log('\n=== END TEST ===');

package/test-lunch-debug.js

@@ -0,0 +1,110 @@
+// Test script to debug why Monday lunch isn't showing
+const { getAvailableTimeblocks } = require('./getAvailableTimeblocks');
+const { timeblocksAvailable } = require('./processing/timeblocksAvailable');
+const { getDailyGuestCounts } = require('./processing/dailyGuestCounts');
+
+// Your restaurant data
+const restaurantData = {
+  "_id": "demo",
+  "openinghours-lunch": {
+    "schemeSettings": {
+      "Monday": {
+        "enabled": true,
+        "startTime": "14:15",
+        "endTime": "15:00",
+        "maxCapacityEnabled": true,
+        "maxCapacity": "10",
+        "shiftsEnabled": false,
+        "shifts": [],
+        "giftcardsEnabled": false,
+        "giftcards": [],
+        "giftcardTakeawayEnabled": false,
+        "giftcardTakeawayStart": "",
+        "giftcardTakeawayEnd": ""
+      },
+      "Wednesday": {
+        "enabled": true,
+        "startTime": "13:45",
+        "endTime": "14:45",
+        "maxCapacityEnabled": false,
+        "maxCapacity": "",
+        "shiftsEnabled": false,
+        "shifts": [],
+        "giftcardsEnabled": false,
+        "giftcards": [],
+        "giftcardTakeawayEnabled": true,
+        "giftcardTakeawayStart": "11:00",
+        "giftcardTakeawayEnd": "16:00"
+      }
+    }
+  },
+  "general-settings": {
+    "zitplaatsen": 13,
+    "uurOpVoorhand": 0,
+    "dagenInToekomst": 365,
+    "minGasten": 1,
+    "maxGasten": 10,
+    "intervalReservatie": 30,
+    "duurReservatie": 60,
+    "ontbijtStop": "",
+    "lunchStop": "",
+    "dinerStop": ""
+  },
+  "max-arrivals-lunch": {
+    "12:00": 6,
+    "12:15": 1,
+    "12:30": 6,
+    "12:45": 4,
+    "13:00": 10,
+    "14:15": 10,
+    "14:30": 10,
+    "14:45": 10,
+    "storedNumber": 30
+  },
+  "exceptions": [],
+  "blocked-slots": []
+};
+
+// Test for Monday December 8, 2025
+const testDate = "2025-12-08"; // Monday
+const guests = 2;
+const reservations = [];
+
+console.log('=== LUNCH AVAILABILITY DEBUG ===\n');
+console.log('Date:', testDate, '(Monday)');
+console.log('Guests:', guests);
+console.log('Current time:', new Date().toISOString());
+console.log('\n--- Restaurant Settings ---');
+console.log('Lunch Opening Hours (Monday):', restaurantData['openinghours-lunch'].schemeSettings.Monday);
+console.log('General Settings:', restaurantData['general-settings']);
+console.log('Max Arrivals Lunch:', restaurantData['max-arrivals-lunch']);
+
+console.log('\n--- Step 1: getDailyGuestCounts ---');
+const { guestCounts, shiftsInfo } = getDailyGuestCounts(restaurantData, testDate, reservations);
+console.log('Guest Counts:', guestCounts);
+console.log('Shifts Info:', shiftsInfo);
+
+console.log('\n--- Step 2: timeblocksAvailable ---');
+const timeblocks = timeblocksAvailable(restaurantData, testDate, reservations, guests, [], null, false);
+console.log('Available Timeblocks:', timeblocks);
+
+console.log('\n--- Step 3: getAvailableTimeblocks (with filters) ---');
+const finalTimeblocks = getAvailableTimeblocks(restaurantData, testDate, reservations, guests, [], null, false);
+console.log('Final Available Timeblocks:', finalTimeblocks);
+
+console.log('\n--- Step 4: Test with Admin Flag ---');
+const adminTimeblocks = getAvailableTimeblocks(restaurantData, testDate, reservations, guests, [], null, true);
+console.log('Admin Timeblocks (no time restrictions):', adminTimeblocks);
+
+// Check if lunch times exist
+const lunchTimes = ['14:15', '14:30', '14:45'];
+console.log('\n--- Lunch Time Analysis ---');
+lunchTimes.forEach(time => {
+  console.log(`${time}:`);
+  console.log(`  - In guestCounts: ${guestCounts.hasOwnProperty(time) ? 'YES (capacity: ' + guestCounts[time] + ')' : 'NO'}`);
+  console.log(`  - In timeblocks: ${timeblocks.hasOwnProperty(time) ? 'YES' : 'NO'}`);
+  console.log(`  - In final: ${finalTimeblocks.hasOwnProperty(time) ? 'YES' : 'NO'}`);
+  console.log(`  - In admin: ${adminTimeblocks.hasOwnProperty(time) ? 'YES' : 'NO'}`);
+});
+
+console.log('\n=== END DEBUG ===');

package/test-max-arrivals-filter.js

@@ -0,0 +1,79 @@
+// Test the max arrivals filter specifically
+const { filterTimeblocksByMaxArrivals } = require('./filters/maxArrivalsFilter');
+const { getAvailableTimeblocks } = require('./getAvailableTimeblocks');
+
+const restaurantData = {
+  "_id": "demo",
+  "openinghours-lunch": {
+    "schemeSettings": {
+      "Monday": {
+        "enabled": true,
+        "startTime": "14:15",
+        "endTime": "15:00",
+        "maxCapacityEnabled": true,
+        "maxCapacity": "10"
+      }
+    }
+  },
+  "general-settings": {
+    "zitplaatsen": 13,
+    "uurOpVoorhand": 0,
+    "dagenInToekomst": 365,
+    "intervalReservatie": 30,
+    "duurReservatie": 60,
+    "ontbijtStop": "",
+    "lunchStop": "",
+    "dinerStop": ""
+  },
+  "max-arrivals-lunch": {
+    "12:00": 6,
+    "12:15": 1,
+    "12:30": 6,
+    "12:45": 4,
+    "13:00": 10,
+    "14:15": 10,
+    "14:30": 10,
+    "14:45": 10,
+    "storedNumber": 30
+  }
+};
+
+const testDate = "2025-12-08";
+const guests = 2;
+const reservations = [];
+
+console.log('=== MAX ARRIVALS FILTER TEST ===\n');
+
+// Get initial timeblocks from algorithm
+const timeblocks = getAvailableTimeblocks(restaurantData, testDate, reservations, guests, [], null, true);
+console.log('Timeblocks from algorithm (admin mode):', Object.keys(timeblocks));
+
+// Apply max arrivals filter
+const filtered = filterTimeblocksByMaxArrivals(restaurantData, testDate, timeblocks, reservations, guests);
+console.log('\nAfter max arrivals filter:', Object.keys(filtered));
+
+// Debug each time slot
+console.log('\n--- Detailed Analysis ---');
+for (const time of Object.keys(timeblocks)) {
+  const maxArrivalsConfig = restaurantData['max-arrivals-lunch'];
+  const maxArrivals = maxArrivalsConfig ? maxArrivalsConfig[time] : null;
+
+  const currentArrivals = reservations
+    .filter(r => r.date === testDate && r.time === time)
+    .reduce((sum, r) => sum + (parseInt(r.guests, 10) || 0), 0);
+
+  const isInFiltered = filtered.hasOwnProperty(time);
+
+  console.log(`\n${time}:`);
+  console.log(`  Max arrivals setting: ${maxArrivals || 'NOT SET'}`);
+  console.log(`  Current arrivals: ${currentArrivals}`);
+  console.log(`  New reservation: ${guests} guests`);
+  console.log(`  Total after adding: ${currentArrivals + guests}`);
+  console.log(`  Passes filter: ${isInFiltered ? 'YES' : 'NO'}`);
+
+  if (maxArrivals !== null && maxArrivals !== undefined) {
+    console.log(`  Logic: ${currentArrivals} + ${guests} = ${currentArrivals + guests} ${currentArrivals + guests <= maxArrivals ? '<=' : '>'} ${maxArrivals}`);
+  }
+}
+
+console.log('\n=== END TEST ===');

package/test-timezone-debug.js

@@ -0,0 +1,47 @@
+// Test timezone handling
+const moment = require('moment-timezone');
+
+const testDate = "2025-12-08";
+const testTime = "14:15";
+
+console.log('=== TIMEZONE DEBUG ===\n');
+
+// What the algorithm does
+const now = new Date();
+console.log('System now:', now);
+console.log('System now ISO:', now.toISOString());
+console.log('System now local string:', now.toString());
+
+// Parse the time as the algorithm does (line 68-69 in getAvailableTimeblocks.js)
+const [year, month, day] = testDate.split('-').map(Number);
+const targetDateInTimeZone = new Date(year, month - 1, day);
+console.log('\nTarget date:', targetDateInTimeZone);
+console.log('Target date string:', targetDateInTimeZone.toString());
+
+const isToday = now.toDateString() === targetDateInTimeZone.toDateString();
+console.log('\nIs today?:', isToday);
+
+// With uurOpVoorhand = 0
+const uurOpVoorhand = 0;
+const cutoffTime = new Date(now.getTime());
+cutoffTime.setHours(cutoffTime.getHours() + uurOpVoorhand);
+console.log('\nCutoff time (now + 0 hours):', cutoffTime);
+console.log('Cutoff time string:', cutoffTime.toString());
+
+// Parse the test time
+const [hours, minutes] = testTime.split(':').map(Number);
+const timeBlockDateTime = new Date(year, month - 1, day, hours, minutes);
+console.log('\nTime block (14:15):', timeBlockDateTime);
+console.log('Time block string:', timeBlockDateTime.toString());
+
+console.log('\nComparison:');
+console.log('timeBlockDateTime < cutoffTime:', timeBlockDateTime < cutoffTime);
+console.log('Should be filtered out?:', timeBlockDateTime < cutoffTime ? 'YES' : 'NO');
+
+// Check with Europe/Brussels timezone
+console.log('\n=== Using moment-timezone ===');
+const nowBrussels = moment.tz('Europe/Brussels');
+console.log('Now in Brussels:', nowBrussels.format('YYYY-MM-DD HH:mm:ss Z'));
+const targetTimeBrussels = moment.tz(`${testDate} ${testTime}`, 'YYYY-MM-DD HH:mm', 'Europe/Brussels');
+console.log('Target time in Brussels:', targetTimeBrussels.format('YYYY-MM-DD HH:mm:ss Z'));
+console.log('Is target time in past?:', targetTimeBrussels.isBefore(nowBrussels));