@happychef/algorithm 1.2.13 → 1.2.14

package/assignTables.js

@@ -299,10 +299,19 @@ async function assignTablesIfPossible({
       }
     }
 
-    // 5) Get duration and interval settings
-    const duurReservatie = parseInt(
+    // 5) Get duration from reservation or settings
+    let duurReservatie = parseInt(
       restaurantSettings["general-settings"]?.duurReservatie?.$numberInt || restaurantSettings["general-settings"]?.duurReservatie || 120
     );
+    // Use reservation specific duration if provided
+    if (reservation.duration) {
+      const rawDur = reservation.duration.$numberInt ?? reservation.duration;
+      const parsedDur = parseInt(rawDur, 10);
+      if (!isNaN(parsedDur) && parsedDur > 0) {
+        duurReservatie = parsedDur;
+      }
+    }
+
     const intervalReservatie = parseInt(
       restaurantSettings["general-settings"]?.intervalReservatie?.$numberInt || restaurantSettings["general-settings"]?.intervalReservatie || 30
     );
@@ -322,7 +331,17 @@ async function assignTablesIfPossible({
       // No need to skip the current reservation as it's not yet inserted
 
       // compute that reservation's time slots
-      const rDuration = duurReservatie; // assuming same duration
+      // Use reservation specific duration if available, else default
+      let rDuration = duurReservatie;
+      if (r.duration) {
+        // Handle both direct value and MongoDB $numberInt
+        // Use ?? to correctly handle 0 values
+        const rawDur = r.duration.$numberInt ?? r.duration;
+        const parsed = parseInt(rawDur, 10);
+        if (!isNaN(parsed) && parsed > 0) {
+          rDuration = parsed;
+        }
+      }
       const rSlots = computeRequiredSlots(r.time, rDuration, intervalReservatie);
 
       if (r.tables) {

package/getAvailableTimeblocks.js

@@ -30,7 +30,7 @@ function parseDateTimeInTimeZone(dateStr, timeStr, timeZone) {
  * @param {boolean} isAdmin - Optional flag to bypass time restrictions for admin users.
  * @returns {Object} - Returns a pruned object of available time blocks or shifts, or an empty object if out of range.
  */
-function getAvailableTimeblocks(data, dateStr, reservations, guests, blockedSlots = [], giftcard = null, isAdmin = false) {
+function getAvailableTimeblocks(data, dateStr, reservations, guests, blockedSlots = [], giftcard = null, isAdmin = false, duration = null) {
   // Get 'uurOpVoorhand' from general settings
   let uurOpVoorhand = 0;
   if (
@@ -79,7 +79,7 @@ function getAvailableTimeblocks(data, dateStr, reservations, guests, blockedSlot
     currentTimeInTimeZone.toDateString() === targetDateInTimeZone.toDateString();
 
   // Get available time blocks or shifts
-  const availableTimeblocks = timeblocksAvailable(data, dateStr, reservations, guests, blockedSlots, giftcard, isAdmin);
+  const availableTimeblocks = timeblocksAvailable(data, dateStr, reservations, guests, blockedSlots, giftcard, isAdmin, duration);
 
   // If the date is today and uurOpVoorhand is greater than zero, prune time blocks (skip for admin)
   if (!isAdmin && isToday && uurOpVoorhand >= 0) {

package/isDateAvailable.js

@@ -62,14 +62,14 @@ function isDateWithinAllowedRange(data, dateStr) {
  * @param {boolean} isAdmin - Optional flag to bypass time restrictions for admin users.
  * @returns {boolean} - Returns true if the date has at least one available timeblock, false otherwise.
  */
-function isDateAvailable(data, dateStr, reservations, guests, blockedSlots = [], giftcard = null, isAdmin = false) {
+function isDateAvailable(data, dateStr, reservations, guests, blockedSlots = [], giftcard = null, isAdmin = false, duration = null) {
   // Check if date is within allowed range (skip for admin)
   if (!isAdmin && !isDateWithinAllowedRange(data, dateStr)) {
     return false;
   }
 
   // Get available timeblocks using the existing logic
-  const availableTimeblocks = getAvailableTimeblocks(data, dateStr, reservations, guests, blockedSlots, giftcard, isAdmin);
+  const availableTimeblocks = getAvailableTimeblocks(data, dateStr, reservations, guests, blockedSlots, giftcard, isAdmin, duration);
 
   // Return true only if we have at least one available timeblock
   return Object.keys(availableTimeblocks).length > 0;

package/isDateAvailableWithTableCheck.js

@@ -74,7 +74,7 @@ function timeHasGiftcard(data, dateStr, timeStr, giftcard) {
  * @param {boolean} isAdmin - Optional flag to bypass time restrictions for admin users.
  * @returns {boolean} - Returns true if the date passes all checks to be available.
  */
-function isDateAvailableWithTableCheck(data, dateStr, reservations, guests, blockedSlots = [], selectedGiftcard = null, isAdmin = false) {
+function isDateAvailableWithTableCheck(data, dateStr, reservations, guests, blockedSlots = [], selectedGiftcard = null, isAdmin = false, duration = null) {
   // 0) Optionally filter by selected menu item's date range (only when normalOpeningTimes = false)
   const currentItem = typeof window !== 'undefined' ? window.currentReservationTicketItem : null;
   if (
@@ -114,7 +114,7 @@ function isDateAvailableWithTableCheck(data, dateStr, reservations, guests, bloc
   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, blockedSlots, selectedGiftcard, isAdmin);
+  const basicDateAvailable = isDateAvailable(data, dateStr, reservations, guests, blockedSlots, selectedGiftcard, isAdmin, duration);
   if (!basicDateAvailable) {
     console.log(`Date ${dateStr} fails basic availability check`);
     return false;
@@ -128,7 +128,7 @@ function isDateAvailableWithTableCheck(data, dateStr, reservations, guests, bloc
 
   // 2) Get all available timeblocks for this date
   console.log(`Getting available timeblocks for ${dateStr}`);
-  const availableTimeblocks = getAvailableTimeblocks(data, dateStr, reservations, guests, blockedSlots, selectedGiftcard, isAdmin);
+  const availableTimeblocks = getAvailableTimeblocks(data, dateStr, reservations, guests, blockedSlots, selectedGiftcard, isAdmin, duration);
   console.log(`Found ${Object.keys(availableTimeblocks).length} available timeblocks before table check`);
 
   // If no timeblocks are available at all, exit early
@@ -153,7 +153,8 @@ function isDateAvailableWithTableCheck(data, dateStr, reservations, guests, bloc
     }
 
     console.log(`Checking table availability for ${time} on ${dateStr} for ${guests} guests`);
-    if (isTimeAvailableSync(data, dateStr, time, guests, reservations)) {
+    // Pass null for selectedZitplaats, then duration
+    if (isTimeAvailableSync(data, dateStr, time, guests, reservations, null, duration)) {
       console.log(`Found available time ${time} with table assignment!`);
       atLeastOneAvailable = true;
       break;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@happychef/algorithm",
-  "version": "1.2.13",
+  "version": "1.2.14",
   "description": "Restaurant and reservation algorithm utilities",
   "main": "index.js",
   "scripts": {

package/processing/timeblocksAvailable.js

@@ -89,8 +89,8 @@ function fitsWithinMeal(data, dateStr, startTimeStr, duurReservatie) {
   return startTime >= mealStartTime && startTime + duurReservatie <= mealEndTime;
 }
 
-function timeblocksAvailable(data, dateStr, reservations, guests, blockedSlots = [], giftcard = null, isAdmin = false) {
-  const duurReservatie = getDuurReservatie(data);
+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

package/reservation_data/counter.js

@@ -48,7 +48,17 @@ function parseTime(timeStr) {
   
 	  const startTime = parseTime(reservation.time);
 
-	  const endTime = startTime + duurReservatie; // Use 'duurReservatie' from general settings
+	  // Use reservation specific duration if available, else default
+	  let rDuration = duurReservatie;
+	  if (reservation.duration) {
+		const rawDur = reservation.duration.$numberInt ?? reservation.duration;
+		const parsed = parseInt(rawDur, 10);
+		if (!isNaN(parsed) && parsed > 0) {
+			rDuration = parsed;
+		}
+	  }
+
+	  const endTime = startTime + rDuration;
   	  // Check if the target time is within the reservation time range
 	  // Start time is inclusive, end time is exclusive
 	  if (targetTime >= startTime && targetTime < endTime) {

package/simulateTableAssignment.js

@@ -322,7 +322,7 @@ function findMultiTableCombination(tables, guestsTotal, startIndex, currentSet,
     }
 }
 
-function assignTablesForGivenTime(restaurantData, date, time, guests, tableOccupiedSlots, selectedZitplaats = null) {
+function assignTablesForGivenTime(restaurantData, date, time, guests, tableOccupiedSlots, selectedZitplaats = null, duration = null) {
     console.log(`[assignTablesForGivenTime] Processing ${date} ${time} for ${guests} guests`);
 
     // Clear cache if it gets too large (prevent memory leaks)
@@ -341,6 +341,11 @@ function assignTablesForGivenTime(restaurantData, date, time, guests, tableOccup
     duurReservatie = safeParseInt(generalSettings.duurReservatie, 120);
     intervalReservatie = safeParseInt(generalSettings.intervalReservatie, 15);
 
+    // Use passed duration if available, otherwise default
+    if (duration && duration > 0) {
+        duurReservatie = duration;
+    }
+
     console.log(`[assignTablesForGivenTime] Using duration: ${duurReservatie}min, interval: ${intervalReservatie}min`);
 
     if (intervalReservatie <= 0) {
@@ -411,8 +416,8 @@ function assignTablesForGivenTime(restaurantData, date, time, guests, tableOccup
     return best.tables.map(t => t.tableNumber);
 }
 
-function isTimeAvailableSync(restaurantData, date, time, guests, reservations, selectedZitplaats = null) {
-    console.log(`\n[isTimeAvailableSync] Checking ${date} ${time} for ${guests} guests`);
+function isTimeAvailableSync(restaurantData, date, time, guests, reservations, selectedZitplaats = null, duration = null) {
+    console.log(`\n[isTimeAvailableSync] Checking ${date} ${time} for ${guests} guests (duration: ${duration || 'default'})`);
     
     if (guests < 0) {
         console.log(`[isTimeAvailableSync] Detected negative guest count (${guests}), adjusting to default of 2`);
@@ -445,19 +450,22 @@ function isTimeAvailableSync(restaurantData, date, time, guests, reservations, s
         }
 
         const generalSettings = restaurantData["general-settings"] || {};
-        let duurReservatie = 120;  // Default: 2 hours in minutes
+        let defaultDuurReservatie = 120;  // Default: 2 hours in minutes
         let intervalReservatie = 15;  // Default: 15 minute intervals
-        duurReservatie = safeParseInt(generalSettings.duurReservatie, 120);
+        defaultDuurReservatie = safeParseInt(generalSettings.duurReservatie, 120);
         intervalReservatie = safeParseInt(generalSettings.intervalReservatie, 15);
         
-        console.log(`[isTimeAvailableSync] Using duration: ${duurReservatie}min, interval: ${intervalReservatie}min`);
+        // Use passed duration or default
+        const currentDuurReservatie = duration && duration > 0 ? duration : defaultDuurReservatie;
+
+        console.log(`[isTimeAvailableSync] Using duration: ${currentDuurReservatie}min (default: ${defaultDuurReservatie}), interval: ${intervalReservatie}min`);
 
         if (intervalReservatie <= 0) {
             console.error(`[isTimeAvailableSync] Invalid interval settings for ${date} ${time}`);
             return false;
         }
 
-        const requiredSlots = computeRequiredSlots(time, duurReservatie, intervalReservatie);
+        const requiredSlots = computeRequiredSlots(time, currentDuurReservatie, intervalReservatie);
         if (!requiredSlots || requiredSlots.length === 0) {
             console.error(`[isTimeAvailableSync] Could not compute required slots for ${date} ${time}`);
             return false; // Cannot proceed if slots are invalid
@@ -477,8 +485,15 @@ function isTimeAvailableSync(restaurantData, date, time, guests, reservations, s
         console.log(`[isTimeAvailableSync] Processing ${reservationsForDate.length} existing reservations on ${date}`);
 
         for (const r of reservationsForDate) {
+            // Calculate duration once per reservation
+            const rDuration = safeParseInt(r.duration, defaultDuurReservatie);
+
+            console.log(`[DEBUG] Reservation ${r.time} (${r.firstName}): Duration=${rDuration}, Tables raw=${JSON.stringify(r.tables)}`);
+
             // NEW: Try to get actual table assignment first
             const actualTables = getActualTableAssignment(r);
+            console.log(`[DEBUG] Reservation ${r.time}: actualTables detected = ${JSON.stringify(actualTables)}`);
+
             let assignedTables = [];
             
             if (actualTables.length > 0) {
@@ -486,14 +501,17 @@ function isTimeAvailableSync(restaurantData, date, time, guests, reservations, s
                 assignedTables = actualTables;
                 console.log(`[isTimeAvailableSync] Using actual table assignment for reservation: ${assignedTables.join(', ')}`);
             } else {
-                // Fall back to simulation for backwards compatibility
+                // ... simulation log ...
                 console.log(`[isTimeAvailableSync] No actual table data, simulating assignment for reservation`);
-                assignedTables = assignTablesForGivenTime(restaurantData, r.date, r.time, r.guests, tableOccupiedSlots);
+                assignedTables = assignTablesForGivenTime(restaurantData, r.date, r.time, r.guests, tableOccupiedSlots, null, rDuration); // Simulation
             }
 
             // Update the occupancy map based on the actual or simulated assignment
             if (assignedTables.length > 0) {
-                const rSlots = computeRequiredSlots(r.time, duurReservatie, intervalReservatie);
+                // Use reservation specific duration if available
+                const rSlots = computeRequiredSlots(r.time, rDuration, intervalReservatie);
+                console.log(`[DEBUG] Reservation ${r.time}: Occupying slots=${rSlots.join(',')} on tables=${assignedTables.join(',')}`);
+
                 if (!rSlots || rSlots.length === 0) continue; // Skip if slots invalid
 
                 assignedTables.forEach(tableNumber => {
@@ -502,8 +520,6 @@ function isTimeAvailableSync(restaurantData, date, time, guests, reservations, s
                     }
                     rSlots.forEach(slot => tableOccupiedSlots[tableNumber].add(slot));
                 });
-                
-                console.log(`[isTimeAvailableSync] Marked tables ${assignedTables.join(', ')} as occupied for time ${r.time}`);
             }
         }
 
@@ -566,7 +582,7 @@ function isTimeAvailableSync(restaurantData, date, time, guests, reservations, s
     }
 }
 
-function filterTimeblocksByTableAvailability(restaurantData, date, timeblocks, guests, reservations, selectedZitplaats = null) {
+function filterTimeblocksByTableAvailability(restaurantData, date, timeblocks, guests, reservations, selectedZitplaats = null, duration = null) {
     console.log(`[filterTimeblocksByTableAvailability] Filtering timeblocks for ${date} with ${guests} guests`);
     
     if (guests < 0) {
@@ -590,7 +606,7 @@ function filterTimeblocksByTableAvailability(restaurantData, date, timeblocks, g
     let unavailableCount = 0;
 
     for (const time in timeblocks) {
-        if (isTimeAvailableSync(restaurantData, date, time, guests, reservations, selectedZitplaats)) {
+        if (isTimeAvailableSync(restaurantData, date, time, guests, reservations, selectedZitplaats, duration)) {
             filteredTimeblocks[time] = timeblocks[time];
             availableCount++;
         } else {
@@ -606,8 +622,8 @@ function filterTimeblocksByTableAvailability(restaurantData, date, timeblocks, g
     return filteredTimeblocks;
 }
 
-function getAvailableTimeblocksWithTableCheck(restaurantData, date, timeblocks, guests, reservations, selectedZitplaats = null) {
-    return filterTimeblocksByTableAvailability(restaurantData, date, timeblocks, guests, reservations, selectedZitplaats);
+function getAvailableTimeblocksWithTableCheck(restaurantData, date, timeblocks, guests, reservations, selectedZitplaats = null, duration = null) {
+    return filterTimeblocksByTableAvailability(restaurantData, date, timeblocks, guests, reservations, selectedZitplaats, duration);
 }
 
 function getAvailableTablesForTime(restaurantData, date, time, guests, reservations, selectedZitplaats = null) {
@@ -656,17 +672,18 @@ function getAvailableTablesForTime(restaurantData, date, time, guests, reservati
 
         console.log(`[getAvailableTablesForTime] Building occupancy map (Processing ${reservationsForDate.length} existing reservations)`);
         for (const r of reservationsForDate) {
+            const rDuration = safeParseInt(r.duration, duurReservatie);
             const actualTables = getActualTableAssignment(r);
             let assignedTables = [];
             
             if (actualTables.length > 0) {
                 assignedTables = actualTables;
             } else {
-                assignedTables = assignTablesForGivenTime(restaurantData, r.date, r.time, r.guests, tableOccupiedSlots, null);
+                assignedTables = assignTablesForGivenTime(restaurantData, r.date, r.time, r.guests, tableOccupiedSlots, null, rDuration);
             }
             
             if (assignedTables.length > 0) {
-                const rSlots = computeRequiredSlots(r.time, duurReservatie, intervalReservatie);
+                const rSlots = computeRequiredSlots(r.time, rDuration, intervalReservatie);
                  if (!rSlots || rSlots.length === 0) continue;
                 assignedTables.forEach(tableNumber => {
                     if (!tableOccupiedSlots[tableNumber]) {