@happychef/algorithm 1.0.0

package/simulateTableAssignment.js

@@ -0,0 +1,594 @@
+// =============================================================================
+// FILE: simulateTableAssignment.js (UPDATED)
+// =============================================================================
+// Archief/Fields/algorithm/simulateTableAssignment.js
+
+// --- Import Helpers ---
+const {
+    getAllTables,
+    isTemporaryTableValid,
+} = require('./tableHelpers');
+
+
+/**
+ * Robust helper for parsing numeric values from various formats.
+ * Handles MongoDB $numberInt format and regular values.
+ */
+function safeParseInt(val, defaultValue) {
+    console.log(`[safeParseInt] Parsing value:`, val, `with type:`, typeof val);
+    
+    if (val === undefined || val === null) return defaultValue;
+    
+    if (typeof val === 'object' && val !== null && '$numberInt' in val) {
+        try {
+            const parsed = parseInt(val.$numberInt, 10);
+            console.log(`[safeParseInt] Parsed $numberInt format:`, parsed);
+            if (!isNaN(parsed)) return parsed;
+        } catch (e) {
+            console.log(`[safeParseInt] Error parsing $numberInt:`, e);
+        }
+        return defaultValue;
+    }
+    
+    if (typeof val === 'number' && !isNaN(val)) {
+        console.log(`[safeParseInt] Using numeric value directly:`, val);
+        return val;
+    }
+    
+    if (typeof val === 'string') {
+        try {
+            const parsed = parseInt(val, 10);
+            console.log(`[safeParseInt] Parsed string:`, parsed);
+            if (!isNaN(parsed)) return parsed;
+        } catch (e) {
+            console.log(`[safeParseInt] Error parsing string:`, e);
+        }
+    }
+    console.log(`[safeParseInt] Could not parse, using default:`, defaultValue);
+    return defaultValue;
+}
+
+/**
+ * Extracts actual table numbers from a reservation's tables array.
+ * Handles MongoDB $numberInt format.
+ */
+function extractTableNumbers(tablesArray) {
+    if (!Array.isArray(tablesArray)) {
+        return [];
+    }
+    
+    return tablesArray.map(table => {
+        return safeParseInt(table, null);
+    }).filter(tableNum => tableNum !== null);
+}
+
+/**
+ * Gets actual table assignments from reservation data if available.
+ * @param {Object} reservation - The reservation object
+ * @returns {Array} Array of table numbers that are actually assigned, or empty array if no data
+ */
+function getActualTableAssignment(reservation) {
+    // Check if reservation has actual table assignments
+    if (reservation.tables && Array.isArray(reservation.tables)) {
+        const tableNumbers = extractTableNumbers(reservation.tables);
+        console.log(`[getActualTableAssignment] Found actual table assignment for reservation:`, tableNumbers);
+        return tableNumbers;
+    }
+    
+    console.log(`[getActualTableAssignment] No actual table assignment found for reservation`);
+    return [];
+}
+
+/**
+ * Converts a reservation's start time and duration into discrete time slots (in minutes from midnight).
+ */
+function computeRequiredSlots(timeString, durationMinutes, intervalMinutes) {
+    const timePattern = /^([01]\d|2[0-3]):([0-5]\d)$/;
+    if (!timeString || !timePattern.test(timeString)) {
+        console.error(`Invalid time format for computeRequiredSlots: ${timeString}. Expected 'HH:MM'.`);
+        return [];
+    }
+
+    const [hour, minute] = timeString.split(":").map(Number);
+    const startMinutes = hour * 60 + minute;
+
+    if (intervalMinutes <= 0) {
+        console.error("Interval must be positive in computeRequiredSlots.");
+        return [startMinutes];
+    }
+
+    const slotCount = Math.ceil(durationMinutes / intervalMinutes);
+    console.log(`Computing ${slotCount} slots for time ${timeString} (duration: ${durationMinutes}min, interval: ${intervalMinutes}min)`);
+
+    const slots = [];
+    for (let i = 0; i < slotCount; i++) {
+        slots.push(startMinutes + i * intervalMinutes);
+    }
+    
+    return slots;
+}
+
+/**
+ * Checks if the given tableNumber is free for all requiredSlots based on the occupied map.
+ */
+function isTableFreeForAllSlots(tableNumber, requiredSlots, tableOccupiedSlots) {
+    const occupiedSlots = tableOccupiedSlots[tableNumber] || new Set();
+    
+    for (const slot of requiredSlots) {
+        if (occupiedSlots.has(slot)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+/**
+ * Calculates Euclidean distance between two tables (assuming x, y properties).
+ */
+function calculateDistance(tableA, tableB) {
+    if (tableA?.x === undefined || tableA?.y === undefined || tableB?.x === undefined || tableB?.y === undefined) {
+        return Infinity; // Cannot calculate distance if coordinates are missing
+    }
+    const dx = tableA.x - tableB.x;
+    const dy = tableA.y - tableB.y;
+    return Math.sqrt(dx * dx + dy * dy);
+}
+
+/**
+ * Backtracking function to find a combination of tables (multi-table assignment).
+ */
+function findMultiTableCombination(tables, guestsNeeded, startIndex, currentSet, best, requiredSlots, tableOccupiedSlots, reservationDateStr, reservationTimeStr) {
+    // Base case: All guests are seated
+    if (guestsNeeded <= 0) {
+        // Calculate total distance for the current combination
+        let distanceSum = 0;
+        for (let i = 0; i < currentSet.length; i++) {
+            for (let j = i + 1; j < currentSet.length; j++) {
+                distanceSum += calculateDistance(currentSet[i], currentSet[j]);
+            }
+        }
+        // Update best solution if this one is better (fewer tables, then lower distance)
+        if (currentSet.length < best.tableCount || (currentSet.length === best.tableCount && distanceSum < best.minDistance)) {
+            best.minDistance = distanceSum;
+            best.tables = [...currentSet]; // Store a copy
+            best.tableCount = currentSet.length;
+            console.log(`Found new best table combination: ${best.tables.map(t => t.tableNumber).join(', ')} for ${guestsNeeded} guests`);
+        }
+        return;
+    }
+
+    if (startIndex >= tables.length) {
+        return;
+    }
+
+    if (currentSet.length >= best.tableCount && best.tableCount !== Infinity) {
+        return; // Pruning based on table count
+    }
+
+    let maxPossibleCapacity = 0;
+    for (let i = startIndex; i < tables.length; i++) {
+        const tbl = tables[i];
+        // Only consider valid & free tables for potential capacity
+        if (isTemporaryTableValid(tbl, reservationDateStr, reservationTimeStr) &&
+            isTableFreeForAllSlots(tbl.tableNumber, requiredSlots, tableOccupiedSlots)) 
+        {
+            maxPossibleCapacity += tbl.maxCapacity;
+        }
+    }
+    
+    if (maxPossibleCapacity < guestsNeeded) {
+        return; // Impossible to seat remaining guests
+    }
+
+    for (let i = startIndex; i < tables.length; i++) {
+        const tbl = tables[i];
+
+        // --- Core Checks ---
+        // 1. Check if temporary table is valid for this date/time
+        if (!isTemporaryTableValid(tbl, reservationDateStr, reservationTimeStr)) {
+            continue; // Skip invalid temporary table
+        }
+        
+        // 2. Check if table is free for all required slots
+        if (!isTableFreeForAllSlots(tbl.tableNumber, requiredSlots, tableOccupiedSlots)) {
+            continue; // Skip occupied table
+        }
+        
+        // 3. Check if table contributes meaningfully
+        const canSeat = Math.min(tbl.maxCapacity, guestsNeeded);
+        if (canSeat < tbl.minCapacity && canSeat < guestsNeeded) {
+            continue; // Don't use a table for fewer than its min capacity unless it fulfills the remainder
+        }
+        
+        if (canSeat <= 0) continue; // Table doesn't help
+
+        // --- Recurse ---
+        currentSet.push(tbl); // Add table to current combination
+        console.log(`Trying table ${tbl.tableNumber} (${tbl.minCapacity}-${tbl.maxCapacity}) for ${canSeat}/${guestsNeeded} guests`);
+        
+        findMultiTableCombination(
+            tables,
+            guestsNeeded - canSeat, // Reduce guests needed
+            i + 1, // Explore next tables
+            currentSet,
+            best,
+            requiredSlots,
+            tableOccupiedSlots,
+            reservationDateStr,
+            reservationTimeStr
+        );
+        
+        currentSet.pop(); // Backtrack: remove table to explore other combinations
+    }
+}
+
+function assignTablesForGivenTime(restaurantData, date, time, guests, tableOccupiedSlots, selectedZitplaats = null) {
+    console.log(`[assignTablesForGivenTime] Processing ${date} ${time} for ${guests} guests`);
+    
+    // FIXED: More robust parsing of settings with detailed logging
+    const generalSettings = restaurantData["general-settings"] || {};
+    console.log("[assignTablesForGivenTime] General settings:", generalSettings);
+    
+    // Check what format the data is in
+    console.log("[assignTablesForGivenTime] duurReservatie format:", typeof generalSettings.duurReservatie);
+    console.log("[assignTablesForGivenTime] intervalReservatie format:", typeof generalSettings.intervalReservatie);
+    
+    // Check for MongoDB format
+    if (typeof generalSettings.duurReservatie === 'object' && generalSettings.duurReservatie?.$numberInt) {
+        console.log("[assignTablesForGivenTime] duurReservatie is in MongoDB format:", generalSettings.duurReservatie?.$numberInt);
+    }
+    
+    if (typeof generalSettings.intervalReservatie === 'object' && generalSettings.intervalReservatie?.$numberInt) {
+        console.log("[assignTablesForGivenTime] intervalReservatie is in MongoDB format:", generalSettings.intervalReservatie?.$numberInt);
+    }
+    
+    // DEFAULT VALUES - this approach mirrors the TypeScript implementation
+    let duurReservatie = 120;  // Default: 2 hours in minutes
+    let intervalReservatie = 15;  // Default: 15 minute intervals
+    
+    // Use safeParseInt for robust parsing
+    duurReservatie = safeParseInt(generalSettings.duurReservatie, 120);
+    intervalReservatie = safeParseInt(generalSettings.intervalReservatie, 15);
+
+    console.log(`[assignTablesForGivenTime] Using duration: ${duurReservatie}min, interval: ${intervalReservatie}min`);
+
+    if (intervalReservatie <= 0) {
+        console.error("Invalid interval settings.");
+        return [];
+    }
+    
+    const requiredSlots = computeRequiredSlots(time, duurReservatie, intervalReservatie);
+    if (!requiredSlots || requiredSlots.length === 0) {
+        console.error(`Could not compute required slots for ${time}`);
+        return [];
+    }
+
+    // Fetch all tables using the imported helper
+    const allTables = getAllTables(restaurantData, selectedZitplaats);
+    console.log(`[assignTablesForGivenTime] Checking ${allTables.length} tables`);
+
+    // --- Try single-table assignment first ---
+    for (const t of allTables) {
+        // Use imported validation function
+        if (!isTemporaryTableValid(t, date, time)) {
+            continue;
+        }
+        
+        if (t.minCapacity <= guests && 
+            guests <= t.maxCapacity && 
+            isTableFreeForAllSlots(t.tableNumber, requiredSlots, tableOccupiedSlots)) 
+        {
+            console.log(`[assignTablesForGivenTime] Assigned single table ${t.tableNumber} for ${guests} guests`);
+            return [t.tableNumber];
+        }
+    }
+
+    console.log(`[assignTablesForGivenTime] No single table found, trying combinations...`);
+
+    // --- Try multi-table assignment ---
+    const best = { minDistance: Infinity, tables: [], tableCount: Infinity };
+    findMultiTableCombination(
+        allTables,
+        guests,
+        0, // Start index
+        [], // Initial empty set
+        best, // Best solution object
+        requiredSlots,
+        tableOccupiedSlots,
+        date, // Pass context
+        time  // Pass context
+    );
+
+    if (best.tables.length > 0) {
+        console.log(`[assignTablesForGivenTime] Found multi-table solution: ${best.tables.map(t => t.tableNumber).join(', ')}`);
+    } else {
+        console.log(`[assignTablesForGivenTime] No table combination found for ${guests} guests`);
+    }
+
+    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`);
+    
+    if (guests < 0) {
+        console.log(`[isTimeAvailableSync] Detected negative guest count (${guests}), adjusting to default of 2`);
+        guests = 2; // Use a reasonable default
+    }
+    
+    const tableSettings = restaurantData?.['table-settings'] || {};
+    const isTableAssignmentEnabled = tableSettings.isInstalled === true &&
+        tableSettings.assignmentMode === "automatic";
+
+    console.log(`[isTimeAvailableSync] Table assignment enabled? ${isTableAssignmentEnabled}`);
+    console.log(`- Table settings installed: ${tableSettings.isInstalled === true}`);
+    console.log(`- Assignment mode: ${tableSettings.assignmentMode}`);
+
+    if (!isTableAssignmentEnabled) {
+        console.log(`[isTimeAvailableSync] No table assignment needed, returning true`);
+        return true;
+    }
+
+    try {
+        // Basic data check
+        if (!restaurantData?.floors || !Array.isArray(restaurantData.floors)) {
+            console.error(`[isTimeAvailableSync] Missing floors data for ${date} ${time}`);
+            return false;
+        }
+        
+        if (guests <= 0) {
+            console.error(`[isTimeAvailableSync] Invalid guest count: ${guests}`);
+            return false; // Cannot reserve for 0 or fewer guests
+        }
+
+        const generalSettings = restaurantData["general-settings"] || {};
+        let duurReservatie = 120;  // Default: 2 hours in minutes
+        let intervalReservatie = 15;  // Default: 15 minute intervals
+        duurReservatie = safeParseInt(generalSettings.duurReservatie, 120);
+        intervalReservatie = safeParseInt(generalSettings.intervalReservatie, 15);
+        
+        console.log(`[isTimeAvailableSync] Using duration: ${duurReservatie}min, interval: ${intervalReservatie}min`);
+
+        if (intervalReservatie <= 0) {
+            console.error(`[isTimeAvailableSync] Invalid interval settings for ${date} ${time}`);
+            return false;
+        }
+
+        const requiredSlots = computeRequiredSlots(time, duurReservatie, 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
+        }
+
+        // --- Build Occupancy Map using ACTUAL table assignments when available ---
+        const tableOccupiedSlots = {}; // { tableNumber: Set<slotMinutes> }
+        const reservationsForDate = reservations
+            .filter(r => r.date === date && r.time && r.guests > 0)
+            .sort((a, b) => {
+                // Simple time string comparison
+                const timeA = a.time.split(':').map(Number);
+                const timeB = b.time.split(':').map(Number);
+                return (timeA[0] * 60 + timeA[1]) - (timeB[0] * 60 + timeB[1]);
+            });
+
+        console.log(`[isTimeAvailableSync] Processing ${reservationsForDate.length} existing reservations on ${date}`);
+
+        for (const r of reservationsForDate) {
+            // NEW: Try to get actual table assignment first
+            const actualTables = getActualTableAssignment(r);
+            let assignedTables = [];
+            
+            if (actualTables.length > 0) {
+                // Use actual table assignment from reservation data
+                assignedTables = actualTables;
+                console.log(`[isTimeAvailableSync] Using actual table assignment for reservation: ${assignedTables.join(', ')}`);
+            } else {
+                // Fall back to simulation for backwards compatibility
+                console.log(`[isTimeAvailableSync] No actual table data, simulating assignment for reservation`);
+                assignedTables = assignTablesForGivenTime(restaurantData, r.date, r.time, r.guests, tableOccupiedSlots);
+            }
+
+            // Update the occupancy map based on the actual or simulated assignment
+            if (assignedTables.length > 0) {
+                const rSlots = computeRequiredSlots(r.time, duurReservatie, intervalReservatie);
+                if (!rSlots || rSlots.length === 0) continue; // Skip if slots invalid
+
+                assignedTables.forEach(tableNumber => {
+                    if (!tableOccupiedSlots[tableNumber]) {
+                        tableOccupiedSlots[tableNumber] = new Set();
+                    }
+                    rSlots.forEach(slot => tableOccupiedSlots[tableNumber].add(slot));
+                });
+                
+                console.log(`[isTimeAvailableSync] Marked tables ${assignedTables.join(', ')} as occupied for time ${r.time}`);
+            }
+        }
+
+        console.log(`[isTimeAvailableSync] Occupancy map built, checking availability for new reservation`);
+
+        const allTables = getAllTables(restaurantData, selectedZitplaats); // Get all tables
+        console.log(`[isTimeAvailableSync] Checking ${allTables.length} tables for new reservation`);
+
+        // 1. Try single table assignment
+        for (const t of allTables) {
+            if (!isTemporaryTableValid(t, date, time)) continue; // Check temporary validity
+
+            if (t.minCapacity <= guests &&
+                guests <= t.maxCapacity &&
+                isTableFreeForAllSlots(t.tableNumber, requiredSlots, tableOccupiedSlots))
+            {
+                console.log(`[isTimeAvailableSync] Found single table ${t.tableNumber} for ${guests} guests at ${time}`);
+                return true; // Available
+            }
+        }
+
+        console.log(`[isTimeAvailableSync] No single table found, trying combinations...`);
+
+        // 2. Try multi-table assignment
+        const best = { minDistance: Infinity, tables: [], tableCount: Infinity };
+        findMultiTableCombination(
+            allTables,
+            guests,
+            0, [], best,
+            requiredSlots,
+            tableOccupiedSlots, // Use the final occupancy map
+            date, time
+        );
+
+        const result = best.tables.length > 0;
+        if (result) {
+            console.log(`[isTimeAvailableSync] Multi-table assignment possible: ${best.tables.map(t => t.tableNumber).join(', ')}`);
+        } else {
+            console.log(`[isTimeAvailableSync] No table combination available`);
+        }
+        
+        return result; // Available if a combination was found
+
+    } catch (error) {
+        console.error(`[isTimeAvailableSync] Error during check for ${date} ${time}:`, error);
+        return false; // Assume unavailable on error
+    }
+}
+
+function filterTimeblocksByTableAvailability(restaurantData, date, timeblocks, guests, reservations, selectedZitplaats = null) {
+    console.log(`[filterTimeblocksByTableAvailability] Filtering timeblocks for ${date} with ${guests} guests`);
+    
+    if (guests < 0) {
+        console.log(`[filterTimeblocksByTableAvailability] Detected negative guest count (${guests}), adjusting to default of 2`);
+        guests = 0; // Use a reasonable default
+    }
+    
+    const tableSettings = restaurantData?.['table-settings'] || {};
+    const isTableAssignmentEnabled = tableSettings.isInstalled === true &&
+        tableSettings.assignmentMode === "automatic";
+
+    if (!isTableAssignmentEnabled) {
+        console.log(`[filterTimeblocksByTableAvailability] No table assignment enabled, returning all timeblocks`);
+        return timeblocks;
+    }
+
+    console.log(`[filterTimeblocksByTableAvailability] Starting with ${Object.keys(timeblocks).length} timeblocks`);
+
+    const filteredTimeblocks = {};
+    let availableCount = 0;
+    let unavailableCount = 0;
+
+    for (const time in timeblocks) {
+        if (isTimeAvailableSync(restaurantData, date, time, guests, reservations, selectedZitplaats)) {
+            filteredTimeblocks[time] = timeblocks[time];
+            availableCount++;
+        } else {
+            unavailableCount++;
+        }
+    }
+
+    console.log(`[filterTimeblocksByTableAvailability] Result: ${availableCount} available, ${unavailableCount} unavailable times`);
+    if (availableCount > 0) {
+        console.log(`[filterTimeblocksByTableAvailability] Available times: ${Object.keys(filteredTimeblocks).join(', ')}`);
+    }
+
+    return filteredTimeblocks;
+}
+
+function getAvailableTimeblocksWithTableCheck(restaurantData, date, timeblocks, guests, reservations, selectedZitplaats = null) {
+    return filterTimeblocksByTableAvailability(restaurantData, date, timeblocks, guests, reservations, selectedZitplaats);
+}
+
+function getAvailableTablesForTime(restaurantData, date, time, guests, reservations, selectedZitplaats = null) {
+    try {
+        if (guests < 0) {
+            console.log(`[getAvailableTablesForTime] Detected negative guest count (${guests}), adjusting to default of 2`);
+            guests = 0;
+        }
+        
+        const tableSettings = restaurantData?.['table-settings'] || {};
+        const isAutomaticAssignment = tableSettings.isInstalled === true &&
+                                       tableSettings.assignmentMode === "automatic";
+
+        if (!isAutomaticAssignment) {
+            return [];
+        }
+
+        if (!restaurantData?.floors || !Array.isArray(restaurantData.floors)) {
+            console.error(`[getAvailableTablesForTime] Missing floors data for ${date} ${time}`);
+            return [];
+        }
+        if (guests <= 0) return [];
+        const generalSettings = restaurantData["general-settings"] || {};
+        const duurReservatie = safeParseInt(generalSettings.duurReservatie, 120);
+        const intervalReservatie = safeParseInt(generalSettings.intervalReservatie, 15);
+        
+        if (intervalReservatie <= 0) {
+             console.error(`[getAvailableTablesForTime] Invalid interval settings for ${date} ${time}`);
+             return [];
+        }
+
+        console.log(`\n[getAvailableTablesForTime] Finding available tables for ${guests} guests on ${date} at ${time}`);
+        const requiredSlots = computeRequiredSlots(time, duurReservatie, intervalReservatie);
+         if (!requiredSlots || requiredSlots.length === 0) {
+            console.error(`[getAvailableTablesForTime] Could not compute required slots for ${date} ${time}`);
+            return [];
+        }
+        const tableOccupiedSlots = {};
+        const reservationsForDate = reservations
+            .filter(r => r.date === date && r.time && r.guests > 0)
+            .sort((a, b) => {
+                const timeA = a.time.split(':').map(Number);
+                const timeB = b.time.split(':').map(Number);
+                return (timeA[0] * 60 + timeA[1]) - (timeB[0] * 60 + timeB[1]);
+            });
+
+        console.log(`[getAvailableTablesForTime] Building occupancy map (Processing ${reservationsForDate.length} existing reservations)`);
+        for (const r of reservationsForDate) {
+            const actualTables = getActualTableAssignment(r);
+            let assignedTables = [];
+            
+            if (actualTables.length > 0) {
+                assignedTables = actualTables;
+            } else {
+                assignedTables = assignTablesForGivenTime(restaurantData, r.date, r.time, r.guests, tableOccupiedSlots, null);
+            }
+            
+            if (assignedTables.length > 0) {
+                const rSlots = computeRequiredSlots(r.time, duurReservatie, intervalReservatie);
+                 if (!rSlots || rSlots.length === 0) continue;
+                assignedTables.forEach(tableNumber => {
+                    if (!tableOccupiedSlots[tableNumber]) {
+                        tableOccupiedSlots[tableNumber] = new Set();
+                    }
+                    rSlots.forEach(slot => tableOccupiedSlots[tableNumber].add(slot));
+                });
+            }
+        }
+        console.log("[getAvailableTablesForTime] Occupancy map built");
+        const allTables = getAllTables(restaurantData, selectedZitplaats); // Get all tables with zitplaats filter applied
+        const availableIndividualTables = [];
+
+        console.log(`[getAvailableTablesForTime] Checking ${allTables.length} tables for individual availability`);
+        for (const t of allTables) {
+            if (!isTemporaryTableValid(t, date, time)) continue;
+            if (t.minCapacity <= guests && guests <= t.maxCapacity) {
+                if (isTableFreeForAllSlots(t.tableNumber, requiredSlots, tableOccupiedSlots)) {
+                    console.log(`[getAvailableTablesForTime] Table ${t.tableNumber} is available`);
+                    availableIndividualTables.push(t); // Storing the whole object might be useful
+                }
+            }
+        }
+
+        console.log(`[getAvailableTablesForTime] Found ${availableIndividualTables.length} individually available tables: ${availableIndividualTables.map(t => t.tableNumber).join(', ')}`);
+        availableIndividualTables.sort((a, b) => a.tableNumber - b.tableNumber);
+
+        return availableIndividualTables; // Return array of table objects
+
+    } catch (error) {
+        console.error(`[getAvailableTablesForTime] Error for ${date} ${time}:`, error);
+        return []; // Return empty on error
+    }
+}
+
+module.exports = {
+    isTimeAvailableSync,
+    filterTimeblocksByTableAvailability,
+    getAvailableTimeblocksWithTableCheck,
+    getAvailableTablesForTime,
+};