@happychef/algorithm 1.2.10 → 1.2.11

package/assignTables.js

@@ -59,7 +59,7 @@ function isTemporaryTableValid(table, reservationDateStr, reservationTimeStr) {
     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;
@@ -70,7 +70,7 @@ function isTemporaryTableValid(table, reservationDateStr, reservationTimeStr) {
     if (!reservationMealType) {
         return false; // Cannot determine meal type for the reservation
     }
-    
+
     if (table.application !== reservationMealType) {
         return false;
     }
@@ -89,7 +89,7 @@ function computeRequiredSlots(timeString, durationMinutes, intervalMinutes) {
     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);
@@ -99,7 +99,7 @@ function computeRequiredSlots(timeString, durationMinutes, intervalMinutes) {
     }
     return slots;
 }
-  
+
 /**
  * isTableFreeForAllSlots(tableNumber, requiredSlots, tableOccupiedSlots)
  * Checks if the given tableNumber is free (no overlapping) for all requiredSlots.
@@ -109,7 +109,7 @@ function isTableFreeForAllSlots(tableNumber, requiredSlots, tableOccupiedSlots)
     // 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).
@@ -119,7 +119,7 @@ function calculateDistance(tableA, tableB) {
     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++) {
@@ -196,7 +196,20 @@ function findMultiTableCombination(
   }
 }
 
-  
+/**
+ * Gets the floor ID linked to a seat place from seatAreaFloorLinks.
+ * @param {Object} restaurantSettings - The restaurant settings object.
+ * @param {string} seatPlace - The seat place identifier.
+ * @returns {string|null} The floor ID or null if not found.
+ */
+function getFloorIdForSeatPlace(restaurantSettings, seatPlace) {
+    if (!seatPlace || !restaurantSettings) return null;
+    const seatAreaFloorLinks = restaurantSettings["general-settings"]?.seatAreaFloorLinks;
+    if (!seatAreaFloorLinks || typeof seatAreaFloorLinks !== 'object') return null;
+    return seatAreaFloorLinks[seatPlace] || null;
+}
+
+
 /**
  * assignTablesIfPossible
  * Attempts to assign tables to a reservation based on availability and constraints.
@@ -211,7 +224,8 @@ async function assignTablesIfPossible({
     const date = reservation.date;
     const time = reservation.time;
     const guests = reservation.guests;
-  
+    const zitplaats = reservation.zitplaats;
+
     // 1) First, fetch restaurant data (which contains the floors information)
     const restaurantSettings = await db.collection('restaurants').findOne({ _id: restaurantId });
     if (!restaurantSettings) {
@@ -221,9 +235,9 @@ async function assignTablesIfPossible({
         return; // Non-enforcing: skip table assignment
       }
     }
-  
+
     // 2) Get floors data directly from the restaurant document
-    const floorsData = restaurantSettings.floors;
+    let floorsData = restaurantSettings.floors;
     if (!floorsData || !Array.isArray(floorsData) || floorsData.length === 0) {
       if (enforceTableAvailability) {
         throw new Error('No floors data found in restaurant document.');
@@ -231,31 +245,51 @@ async function assignTablesIfPossible({
         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
-            });
-          }
-        });
+
+    // 2.5) If zitplaats is specified and has a floor link, try that floor first
+    const linkedFloorId = getFloorIdForSeatPlace(restaurantSettings, zitplaats);
+    let preferredFloorOnly = null;
+    if (linkedFloorId) {
+      const linkedFloor = floorsData.find(f => f.id === linkedFloorId);
+      if (linkedFloor) {
+        preferredFloorOnly = [linkedFloor];
+        console.log(`[Zitplaats] Will try floor '${linkedFloorId}' first for zitplaats '${zitplaats}'`);
       }
-    });
-  
+    }
+
+    // 3) Helper to collect tables from floors
+    function collectTablesFromFloors(floors) {
+      const tables = [];
+      floors.forEach(floor => {
+        if (floor.tables && Array.isArray(floor.tables)) {
+          floor.tables.forEach(tbl => {
+            if (tbl.objectType === "Tafel") {
+              tables.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,
+                startDate: tbl.startDate || null,
+                endDate: tbl.endDate || null,
+                application: tbl.application || null
+              });
+            }
+          });
+        }
+      });
+      return tables;
+    }
+
+    // Collect all tables from all floors
+    let allTables = collectTablesFromFloors(floorsData);
+
+    // Collect tables from preferred floor only (if specified)
+    let preferredFloorTables = preferredFloorOnly ? collectTablesFromFloors(preferredFloorOnly) : null;
+
     // 4) If no tables found
     if (!allTables.length) {
       if (enforceTableAvailability) {
@@ -264,44 +298,33 @@ async function assignTablesIfPossible({
         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
+
+    // 5) 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]) {
@@ -313,86 +336,89 @@ async function assignTablesIfPossible({
         }
       }
     }
-      // ===== 9.5) Table Grouping Attempt (moved to grouping.js) =====
-    try {
-      const groupingResult = tryGroupTables({
-        restaurantSettings,
-        allTables,
-        guests,
-        date,
-        time,
-        requiredSlots,
-        tableOccupiedSlots,
-        isTemporaryTableValid,
-        isTableFreeForAllSlots,
+
+    // 10) Helper function to try table assignment from a given set of tables
+    function tryAssignTables(tables, label) {
+      // Sort tables
+      const sortedTables = [...tables].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;
       });
 
-      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
+      // Try grouping first
+      try {
+        const groupingResult = tryGroupTables({
+          restaurantSettings,
+          allTables: sortedTables,
+          guests,
+          date,
+          time,
+          requiredSlots,
+          tableOccupiedSlots,
+          isTemporaryTableValid,
+          isTableFreeForAllSlots,
+        });
+
+        if (groupingResult) {
+          reservation.tables = groupingResult.tables;
+          reservation.tableIds = groupingResult.tableIds;
+          reservation._viaGroup = groupingResult.viaGroup;
+          console.log(`[${label}] [Grouping] via '${reservation._viaGroup}' -> tables ${reservation.tables.join(",")}`);
+          return true;
+        }
+      } catch (err) {
+        throw err;
       }
-    } 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
+      // Try single-table assignment
+      for (let t of sortedTables) {
+        if (!isTemporaryTableValid(t, date, time)) continue;
+        if (t.minCapacity <= guests && guests <= t.maxCapacity &&
+            isTableFreeForAllSlots(t.tableNumber, requiredSlots, tableOccupiedSlots)) {
+          reservation.tables = [t.tableNumber];
+          reservation.tableIds = [t.tableId];
+          console.log(`[${label}] Assigned to table: ${t.tableNumber}`);
+          return true;
+        }
       }
-      
-      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
+
+      // Try multi-table combination
+      let best = { minDistance: Infinity, tables: [] };
+      findMultiTableCombination(sortedTables, guests, 0, [], best, requiredSlots, tableOccupiedSlots, date, time);
+
+      if (best.tables.length > 0) {
+        reservation.tables = best.tables.map(t => t.tableNumber);
+        reservation.tableIds = best.tables.map(t => t.tableId);
+        console.log(`[${label}] Assigned to tables: ${reservation.tables.join(', ')}`);
+        return true;
       }
+
+      return false;
     }
-  
-    // 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.');
+
+    // 11) Try preferred floor first (if specified), then fall back to all floors
+    if (preferredFloorTables && preferredFloorTables.length > 0) {
+      console.log(`[Zitplaats] Trying preferred floor first (${preferredFloorTables.length} tables)`);
+      if (tryAssignTables(preferredFloorTables, 'PreferredFloor')) {
+        return; // Success on preferred floor
       }
+      console.log(`[Zitplaats] No availability on preferred floor, falling back to all floors`);
+    }
+
+    // 12) Try all floors
+    if (tryAssignTables(allTables, 'AllFloors')) {
+      return; // Success
+    }
+
+    // 13) No valid table combo found
+    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/changes/2025/December/PR4___.md

@@ -0,0 +1,16 @@
+# PR 4 - TEST: Add intentionally failing tests
+
+**Actions:** 
+
+## Changes Summary
+NO_ADDITIONS
+
+NO_REMOVALS
+
+NO_CHANGES
+
+---
+
+**Author:** houssammk123
+**Date:** 2025-12-09
+**PR Link:** https://github.com/thibaultvandesompele2/15-happy-algorithm/pull/4

package/changes/2025/December/PR5___.md

@@ -0,0 +1,16 @@
+# PR 5 - TEST: Add passing helper tests
+
+**Actions:** 
+
+## Changes Summary
+NO_ADDITIONS
+
+NO_REMOVALS
+
+NO_CHANGES
+
+---
+
+**Author:** houssammk123
+**Date:** 2025-12-09
+**PR Link:** https://github.com/thibaultvandesompele2/15-happy-algorithm/pull/5

package/changes/2025/December/PR6__del_.md

@@ -0,0 +1,18 @@
+# PR 6 - Fix remove meaningless tests
+
+**Actions:** 
+
+## Changes Summary
+NO_ADDITIONS
+
+REMOVED:
+- Removed test case `test_remove_meaningless_tests` from the test suite.
+- Removed the entire test file `test_remove_meaningless_tests.py` from the repository.
+
+NO_CHANGES
+
+---
+
+**Author:** houssammk123
+**Date:** 2025-12-09
+**PR Link:** https://github.com/thibaultvandesompele2/15-happy-algorithm/pull/6

package/changes/2025/December/PR7_add__change.md

@@ -0,0 +1,22 @@
+# PR 7 - Fix/infinite loop table assignment
+
+**Actions:** 
+
+## Changes Summary
+ADDED:
+- New function `findTableForParty(tables, partySize)` added to handle table assignment logic.
+- New variable `assignedTables` introduced to track which tables have been assigned.
+- New import `itertools` added to support combination generation for table selection.
+
+NO_REMOVALS
+
+CHANGED:
+- Modified the `assignTables` function in `src/tableAssignment.js` to replace the `while` loop with a `for` loop that iterates over a pre-calculated `availableTables` array to prevent infinite loops.
+- Updated the table selection logic inside the loop from a random index selection (`Math.floor(Math.random() * availableTables.length)`) to a sequential index selection using the loop counter `i`.
+- Changed the condition for breaking out of the assignment loop from checking `remainingGuests > 0` to checking if `availableTables.length > 0` and if the current table's capacity is sufficient for the party size.
+
+---
+
+**Author:** houssammk123
+**Date:** 2025-12-12
+**PR Link:** https://github.com/thibaultvandesompele2/15-happy-algorithm/pull/7

package/jest.config.js

@@ -1,23 +1,23 @@
-module.exports = {
-  testEnvironment: 'node',
-  coverageDirectory: 'coverage',
-  collectCoverageFrom: [
-    '**/*.js',
-    '!**/node_modules/**',
-    '!**/coverage/**',
-    '!jest.config.js',
-    '!test.js',
-    '!test-*.js',
-    '!**/__tests__/**'
-  ],
-  testMatch: [
-    '**/__tests__/**/*.test.js'
-  ],
-  testPathIgnorePatterns: [
-    '/node_modules/',
-    '/test\\.js$',
-    '/test-.*\\.js$'
-  ],
-  verbose: true,
-  testTimeout: 10000
-};
+module.exports = {
+  testEnvironment: 'node',
+  coverageDirectory: 'coverage',
+  collectCoverageFrom: [
+    '**/*.js',
+    '!**/node_modules/**',
+    '!**/coverage/**',
+    '!jest.config.js',
+    '!test.js',
+    '!test-*.js',
+    '!**/__tests__/**'
+  ],
+  testMatch: [
+    '**/__tests__/**/*.test.js'
+  ],
+  testPathIgnorePatterns: [
+    '/node_modules/',
+    '/test\\.js$',
+    '/test-.*\\.js$'
+  ],
+  verbose: true,
+  testTimeout: 10000
+};

package/package.json

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

package/tableHelpers.js

@@ -171,8 +171,8 @@ function isTemporaryTableValid(table, reservationDateStr, reservationTimeStr) {
 // Use CommonJS exports (adjust if using ES6 modules)
 module.exports = {
     shifts,
-    parseTime, // Export if needed elsewhere, otherwise could be kept internal
+    parseTime,
     getMealTypeByTime,
     getAllTables,
     isTemporaryTableValid
-};
+};