@happychef/algorithm 1.0.0

package/assignTables.js

@@ -0,0 +1,398 @@
+const { tryGroupTables } = require("./grouping");
+
+/**
+ * server side
+ * Parses a time string ("HH:MM") into minutes since midnight.
+ * Returns NaN if the format is invalid.
+ */
+function parseTime(timeStr) {
+    if (!timeStr || typeof timeStr !== 'string') return NaN;
+    const parts = timeStr.split(':');
+    if (parts.length !== 2) return NaN;
+    const hours = parseInt(parts[0], 10);
+    const minutes = parseInt(parts[1], 10);
+    if (isNaN(hours) || isNaN(minutes) || hours < 0 || hours > 23 || minutes < 0 || minutes > 59) {
+        return NaN;
+    }
+    return hours * 60 + minutes;
+}
+
+const shifts = {
+    breakfast: { start: '07:00', end: '11:00' },
+    lunch: { start: '11:00', end: '16:00' },
+    dinner: { start: '16:00', end: '23:00' },
+};
+
+/**
+ * Determines the meal type ('breakfast', 'lunch', 'dinner') for a given time string ("HH:MM").
+ * Returns null if the time doesn't fall into a defined shift.
+ */
+function getMealTypeByTime(timeStr) {
+    const time = parseTime(timeStr);
+    if (isNaN(time)) return null;
+
+    for (const [mealType, shift] of Object.entries(shifts)) {
+        const start = parseTime(shift.start);
+        const end = parseTime(shift.end);
+        if (isNaN(start) || isNaN(end)) continue;
+
+        if (time >= start && time < end) {
+            return mealType;
+        }
+    }
+    return null;
+}
+
+/**
+ * Checks if a temporary table is valid for a specific reservation date and time.
+ * @param {Object} table - The table object with isTemporary, startDate, endDate, application properties.
+ * @param {string} reservationDateStr - The date of the reservation ("YYYY-MM-DD").
+ * @param {string} reservationTimeStr - The time of the reservation ("HH:MM").
+ * @returns {boolean} True if the table is valid, false otherwise.
+ */
+function isTemporaryTableValid(table, reservationDateStr, reservationTimeStr) {
+    if (!table.isTemporary) {
+        return true; // Not temporary, always valid (subject to other checks like availability)
+    }
+
+    // Check date range
+    if (!table.startDate || !table.endDate) {
+        return false; // Invalid temporary table definition
+    }
+    
+    // Basic date string comparison (YYYY-MM-DD format)
+    if (reservationDateStr < table.startDate || reservationDateStr > table.endDate) {
+        return false;
+    }
+
+    // Check application (meal type/shift)
+    const reservationMealType = getMealTypeByTime(reservationTimeStr);
+    if (!reservationMealType) {
+        return false; // Cannot determine meal type for the reservation
+    }
+    
+    if (table.application !== reservationMealType) {
+        return false;
+    }
+
+    return true;
+}
+
+/**
+ * computeRequiredSlots(timeString, durationMinutes, intervalMinutes)
+ * Converts a reservation's start time and duration into discrete time slots.
+ * e.g., timeString = "12:30", duration = 400 minutes, interval = 50 minutes
+ */
+function computeRequiredSlots(timeString, durationMinutes, intervalMinutes) {
+    // Validate time format
+    const timePattern = /^([01]\d|2[0-3]):([0-5]\d)$/;
+    if (!timePattern.test(timeString)) {
+      throw new Error("Invalid time format. Expected 'HH:MM'.");
+    }
+  
+    const [hour, minute] = timeString.split(":").map(Number);
+    const startMinutes = hour * 60 + minute;
+    const slotCount = Math.ceil(durationMinutes / intervalMinutes);
+    const slots = [];
+    for (let i = 0; i < slotCount; i++) {
+      slots.push(startMinutes + i * intervalMinutes);
+    }
+    return slots;
+}
+  
+/**
+ * isTableFreeForAllSlots(tableNumber, requiredSlots, tableOccupiedSlots)
+ * Checks if the given tableNumber is free (no overlapping) for all requiredSlots.
+ */
+function isTableFreeForAllSlots(tableNumber, requiredSlots, tableOccupiedSlots) {
+    const occupiedSlots = tableOccupiedSlots[tableNumber] || new Set();
+    // If any slot from requiredSlots is in occupiedSlots, the table is not free
+    return !requiredSlots.some(slot => occupiedSlots.has(slot));
+}
+  
+/**
+ * calculateDistance(tableA, tableB)
+ * Euclidean distance between two tables (for multi-table distance minimization).
+ */
+function calculateDistance(tableA, tableB) {
+    const dx = tableA.x - tableB.x;
+    const dy = tableA.y - tableB.y;
+    return Math.sqrt(dx * dx + dy * dy);
+}
+  
+function distanceSum(set) {
+  let sum = 0;
+  for (let i = 0; i < set.length; i++) {
+    for (let j = i + 1; j < set.length; j++) {
+      sum += calculateDistance(set[i], set[j]);
+    }
+  }
+  return sum;
+}
+
+function findMultiTableCombination(
+  tables,
+  guestsTotal,
+  startIndex,
+  currentSet,
+  best,
+  requiredSlots,
+  tableOccupiedSlots,
+  reservationDate,
+  reservationTime,
+  suffixMax // optional precomputed array
+) {
+  // Precompute suffix max-capacity once
+  if (!suffixMax) {
+    suffixMax = new Array(tables.length + 1).fill(0);
+    for (let i = tables.length - 1; i >= 0; i--) {
+      suffixMax[i] = suffixMax[i + 1] + tables[i].maxCapacity;
+    }
+  }
+
+  // Compute current set min/max sums
+  let curMin = 0, curMax = 0;
+  for (const t of currentSet) {
+    curMin += t.minCapacity;
+    curMax += t.maxCapacity;
+  }
+
+  // Prune: too many required seats already
+  if (curMin > guestsTotal) return;
+  // Prune: even with all remaining tables, can't reach guests
+  if (curMax + suffixMax[startIndex] < guestsTotal) return;
+
+  // Feasible set -> evaluate distance and update best
+  if (curMin <= guestsTotal && guestsTotal <= curMax) {
+    const d = distanceSum(currentSet);
+    if (d < best.minDistance) {
+      best.minDistance = d;
+      best.tables = [...currentSet];
+    }
+    // Continue searching; a tighter cluster may exist.
+  }
+
+  // Try adding more tables
+  for (let i = startIndex; i < tables.length; i++) {
+    const tbl = tables[i];
+
+    if (!isTemporaryTableValid(tbl, reservationDate, reservationTime)) continue;
+    if (!isTableFreeForAllSlots(tbl.tableNumber, requiredSlots, tableOccupiedSlots)) continue;
+
+    currentSet.push(tbl);
+    findMultiTableCombination(
+      tables,
+      guestsTotal,
+      i + 1,
+      currentSet,
+      best,
+      requiredSlots,
+      tableOccupiedSlots,
+      reservationDate,
+      reservationTime,
+      suffixMax
+    );
+    currentSet.pop();
+  }
+}
+
+  
+/**
+ * assignTablesIfPossible
+ * Attempts to assign tables to a reservation based on availability and constraints.
+ * Modifies the reservation object by attaching 'tables' and 'tableIds' if successful.
+ */
+async function assignTablesIfPossible({
+    db,
+    reservation,
+    enforceTableAvailability
+}) {
+    const restaurantId = reservation.restaurantId;
+    const date = reservation.date;
+    const time = reservation.time;
+    const guests = reservation.guests;
+  
+    // 1) First, fetch restaurant data (which contains the floors information)
+    const restaurantSettings = await db.collection('restaurants').findOne({ _id: restaurantId });
+    if (!restaurantSettings) {
+      if (enforceTableAvailability) {
+        throw new Error('Restaurant settings not found.');
+      } else {
+        return; // Non-enforcing: skip table assignment
+      }
+    }
+  
+    // 2) Get floors data directly from the restaurant document
+    const floorsData = restaurantSettings.floors;
+    if (!floorsData || !Array.isArray(floorsData) || floorsData.length === 0) {
+      if (enforceTableAvailability) {
+        throw new Error('No floors data found in restaurant document.');
+      } else {
+        return; // Non-enforcing: skip table assignment
+      }
+    }
+  
+    // 3) Collect all "Tafel" tables
+    let allTables = [];
+    floorsData.forEach(floor => {
+      if (floor.tables && Array.isArray(floor.tables)) {
+        floor.tables.forEach(tbl => {
+          if (tbl.objectType === "Tafel") {
+            allTables.push({
+              tableId: tbl.id,
+              tableNumber: parseInt(tbl.tableNumber.$numberInt || tbl.tableNumber),
+              minCapacity: parseInt(tbl.minCapacity.$numberInt || tbl.minCapacity),
+              maxCapacity: parseInt(tbl.maxCapacity.$numberInt || tbl.maxCapacity),
+              priority: parseInt(tbl.priority.$numberInt || tbl.priority),
+              x: parseInt(tbl.x.$numberInt || tbl.x),
+              y: parseInt(tbl.y.$numberInt || tbl.y),
+              isTemporary: tbl.isTemporary === true, // Added for temporary tables
+              startDate: tbl.startDate || null, // Added for temporary tables
+              endDate: tbl.endDate || null, // Added for temporary tables
+              application: tbl.application || null // Added for temporary tables
+            });
+          }
+        });
+      }
+    });
+  
+    // 4) If no tables found
+    if (!allTables.length) {
+      if (enforceTableAvailability) {
+        throw new Error('No tables found for this restaurant.');
+      } else {
+        return; // Non-enforcing: skip table assignment
+      }
+    }
+  
+    // 5) Sort the tables
+    allTables.sort((a, b) => {
+      if (a.maxCapacity !== b.maxCapacity) {
+        return a.maxCapacity - b.maxCapacity;
+      }
+      if (a.priority !== b.priority) {
+        return a.priority - b.priority;
+      }
+      return a.minCapacity - b.minCapacity;
+    });
+  
+    // 6) Get duration and interval settings
+    const duurReservatie = parseInt(
+      restaurantSettings["general-settings"]?.duurReservatie?.$numberInt || restaurantSettings["general-settings"]?.duurReservatie || 120
+    );
+    const intervalReservatie = parseInt(
+      restaurantSettings["general-settings"]?.intervalReservatie?.$numberInt || restaurantSettings["general-settings"]?.intervalReservatie || 30
+    );
+  
+    // 7) Compute the requiredSlots for this reservation
+    const requiredSlots = computeRequiredSlots(time, duurReservatie, intervalReservatie);
+  
+    // 8) Get overlapping reservations (same date, same restaurant)
+    const overlappingReservations = await db.collection('reservations').find({
+      restaurantId: restaurantId,
+      date: date
+    }).toArray();
+  
+    // 9) Build tableOccupiedSlots map
+    let tableOccupiedSlots = {}; // { [tableNumber]: Set([...slots]) }
+    for (let r of overlappingReservations) {
+      // 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
+      const rSlots = computeRequiredSlots(r.time, rDuration, intervalReservatie);
+  
+      if (r.tables) {
+        for (let tn of r.tables) {
+          if (!tableOccupiedSlots[tn]) {
+            tableOccupiedSlots[tn] = new Set();
+          }
+          rSlots.forEach(slot => {
+            tableOccupiedSlots[tn].add(slot);
+          });
+        }
+      }
+    }
+      // ===== 9.5) Table Grouping Attempt (moved to grouping.js) =====
+    try {
+      const groupingResult = tryGroupTables({
+        restaurantSettings,
+        allTables,
+        guests,
+        date,
+        time,
+        requiredSlots,
+        tableOccupiedSlots,
+        isTemporaryTableValid,
+        isTableFreeForAllSlots,
+      });
+
+      if (groupingResult) {
+        reservation.tables = groupingResult.tables;
+        reservation.tableIds = groupingResult.tableIds;
+        reservation._viaGroup = groupingResult.viaGroup;
+        console.log(
+          `[Grouping] via '${reservation._viaGroup}' -> tables ${reservation.tables.join(",")}`
+        );
+        return; // grouping wins
+      }
+    } catch (err) {
+      // strict grouping throws; preserve original behavior
+      throw err;
+    }
+  // ===== end 9.5) Table Grouping Attempt =====
+
+    // 10) Single-Table Attempt
+    for (let t of allTables) {
+      // Check if temporary table is valid for this date/time
+      if (!isTemporaryTableValid(t, date, time)) {
+        continue; // Skip invalid temporary table
+      }
+      
+      if (
+        t.minCapacity <= guests &&
+        guests <= t.maxCapacity &&
+        isTableFreeForAllSlots(t.tableNumber, requiredSlots, tableOccupiedSlots)
+      ) {
+        // Assign this table to the reservation
+        reservation.tables = [t.tableNumber];
+        reservation.tableIds = [t.tableId];
+        console.log(`Reservation assigned to table: ${t.tableNumber}`);
+        return; // Assignment successful
+      }
+    }
+  
+    // 11) Multi-Table Attempt
+    let best = { minDistance: Infinity, tables: [] };
+  
+    findMultiTableCombination(
+      allTables,
+      guests,
+      0,
+      [],
+      best,
+      requiredSlots,
+      tableOccupiedSlots,
+      date,  // Pass date for temporary table validation
+      time   // Pass time for temporary table validation
+    );
+  
+    if (best.tables.length > 0) {
+      // Assign the best combination to the reservation
+      reservation.tables = best.tables.map(t => t.tableNumber);
+      reservation.tableIds = best.tables.map(t => t.tableId);
+      console.log(`Reservation assigned to tables: ${reservation.tables.join(', ')}`);
+      return; // Assignment successful
+    } else {
+      // If no valid table combo found, either fail (if enforce) or do nothing (if not enforce)
+      if (enforceTableAvailability) {
+        throw new Error('Unable to find enough tables for this reservation with enforcement on.');
+      } else {
+        console.log('No tables available, but non-enforcing mode => continuing without assignment.');
+      }
+    }
+}
+  
+module.exports = {
+    assignTablesIfPossible
+};

package/filters/maxArrivalsFilter.js

@@ -0,0 +1,115 @@
+// file: /src/Pages/NewReservation/StepOne/algorithm/maxArrivalsFilter.js
+
+/**
+ * Simple max arrivals filter for time slots
+ * 
+ * Only considers exact arrivals at each time slot without factoring duration
+ */
+
+/**
+ * Get meal type based on time
+ * @param {string} time - Time string (HH:MM)
+ * @returns {string|null} - Meal type or null
+ */
+function getMealType(time) {
+	const hour = parseInt(time.split(':')[0], 10);
+	
+	if (hour >= 4 && hour < 11) return 'breakfast';
+	if (hour >= 11 && hour < 16) return 'lunch';
+	if (hour >= 16 && hour < 23) return 'dinner';
+	
+	return null;
+  }
+  
+  /**
+   * Extract number value from various data formats
+   * @param {*} value - Value from data object
+   * @returns {number|null} - Number or null
+   */
+  function extractNumber(value) {
+	if (!value) return null;
+	
+	// Handle MongoDB NumberInt format
+	if (value.$numberInt) {
+	  return parseInt(value.$numberInt, 10);
+	}
+	
+	// Handle regular number
+	if (typeof value === 'number') {
+	  return value;
+	}
+	
+	// Handle string number
+	if (typeof value === 'string') {
+	  const parsed = parseInt(value, 10);
+	  return isNaN(parsed) ? null : parsed;
+	}
+	
+	return null;
+  }
+  
+  /**
+   * 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} - Guest count
+   */
+  function countArrivalsAtTime(reservations, date, time) {
+	return reservations
+	  .filter(r => r.date === date && r.time === time)
+	  .reduce((sum, r) => sum + (parseInt(r.guests, 10) || 0), 0);
+  }
+  
+  /**
+   * Filter timeblocks based on max arrivals settings
+   * @param {Object} restaurantData - Restaurant data
+   * @param {string} date - Date string
+   * @param {Object} timeblocks - Available timeblocks
+   * @param {Array} reservations - Existing reservations
+   * @param {number} guests - New reservation guest count
+   * @returns {Object} - Filtered timeblocks
+   */
+  function filterTimeblocksByMaxArrivals(restaurantData, date, timeblocks, reservations, guests) {
+	const filteredBlocks = {};
+	
+	for (const [time, timeData] of Object.entries(timeblocks)) {
+	  // Get meal type for this time
+	  const mealType = getMealType(time);
+	  if (!mealType) {
+		// Keep the timeblock if we can't determine its meal type
+		filteredBlocks[time] = timeData;
+		continue;
+	  }
+	  
+	  // Get max arrivals config for this meal type
+	  const maxArrivalsConfig = restaurantData[`max-arrivals-${mealType}`];
+	  if (!maxArrivalsConfig) {
+		// Keep the timeblock if no max arrivals config for this meal type
+		filteredBlocks[time] = timeData;
+		continue; 
+	  }
+	  
+	  // Get max arrivals value for this specific time
+	  const maxArrivals = extractNumber(maxArrivalsConfig[time]);
+	  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
+	  if (currentArrivals + guests <= maxArrivals) {
+		filteredBlocks[time] = timeData;
+	  }
+	}
+	
+	return filteredBlocks;
+  }
+  
+  module.exports = {
+	filterTimeblocksByMaxArrivals
+  };