User: Task: "Create Handle Recurring Bookings Api"
    Description: "Generate a Node.js Handle Recurring Bookings Api with given dependenceis"
    Requirements:
    - Database: mongoose
    - Authentication: None specified
    - Output needed: Return only the function code as specified in dependencies
    - Dependencies: Create a function to manage recurring bookings. Export: exports.createRecurringBooking = async () => {...}, 
Accept parameters: startDate, endDate, frequency (e.g., weekly, monthly), roomId., 
Validate required fields: Ensure startDate, endDate, frequency, and roomId are provided., 
Use a scheduling library (e.g., node-cron) to generate recurring booking dates based on the frequency., 
Check availability for each recurring date using the checkAvailability function., 
Create bookings for each recurring date and link them to the same user or service., 
Respond with a success message containing the booking details for each occurrence., 
Handle errors like conflicting bookings, invalid parameters, or database issues.
    - Previous Code 
const mongoose = require('mongoose');
const Booking = require('./models/Booking'); // Assume there is a Booking model defined in models/Booking.js

/**
 * Check availability for a booking based on the provided dates and roomId.
 * 
 * @param {Date} checkInDate - The starting date for the booking.
 * @param {Date} checkOutDate - The ending date for the booking.
 * @param {String} roomId - The unique identifier for the room/service.
 * 
 * @returns {Object} - An object containing the availability status and a message.
 */
exports.checkAvailability = async (checkInDate, checkOutDate, roomId) => {
    try {
        // Validate required fields
        if (!checkInDate || !checkOutDate || !roomId) {
            throw new Error('Missing required fields: checkInDate, checkOutDate, and roomId are required');
        }

        // Ensure that checkInDate and checkOutDate are valid dates
        const checkIn = new Date(checkInDate);
        const checkOut = new Date(checkOutDate);
        if (isNaN(checkIn) || isNaN(checkOut)) {
            throw new Error('Invalid date format. Please provide valid checkInDate and checkOutDate.');
        }

        // Query the Booking model to find any conflicting bookings
        const existingBookings = await Booking.find({
            roomId: roomId,
            $or: [
                { checkInDate: { $lt: checkOut }, checkOutDate: { $gt: checkIn } }
            ]
        });

        if (existingBookings.length > 0) {
            // If conflicts exist, room/service is unavailable
            return {
                available: false,
                message: 'Room/Service is unavailable for the selected dates.'
            };
        }

        // If no conflicts exist, room/service is available
        return {
            available: true,
            message: 'Room/Service is available for the selected dates.'
        };
    } catch (error) {
        // Handle errors and provide feedback
        return {
            available: false,
            message: `Error checking availability: ${error.message}`
        };
    }
};

/**
 * Manage time slots for a specific date and service.
 * 
 * @param {String} date - The specific date for time slots.
 * @param {String} serviceId - The unique identifier for the service.
 * @param {Array} availableSlots - An array of proposed time slots.
 * 
 * @returns {Object} - An object containing the success message or errors encountered.
 */
exports.manageTimeSlots = async (date, serviceId, availableSlots) => {
    try {
        // Validate required fields
        if (!date || !serviceId || !Array.isArray(availableSlots)) {
            throw new Error('Missing required fields: date, serviceId, and availableSlots must be provided.');
        }

        // Ensure the date is a valid date
        const specificDate = new Date(date);
        if (isNaN(specificDate)) {
            throw new Error('Invalid date format. Please provide a valid date.');
        }

        // Check for overlapping time slots with existing bookings
        const overlappingBookings = await Booking.find({
            serviceId: serviceId,
            date: specificDate,
            timeSlot: { $in: availableSlots }
        });

        if (overlappingBookings.length > 0) {
            throw new Error('Some of the time slots overlap with existing bookings.');
        }
        
        // Use TimeSlot model to create or update available time slots
        await TimeSlot.updateOne(
            { date: specificDate, serviceId: serviceId },
            { $set: { availableSlots: availableSlots } },
            { upsert: true }
        );

        // Respond with a success message indicating available time slots
        return {
            success: true,
            message: 'Time slots successfully managed for the specified date and service.'
        };
    } catch (error) {
        // Handle errors and provide feedback
        return {
            success: false,
            message: `Error managing time slots: ${error.message}`
        };
    }
};

/**
 * Create a recurring booking based on the provided parameters.
 * 
 * @param {String} startDate - The starting date for the recurring booking.
 * @param {String} endDate - The ending date for the recurring booking.
 * @param {String} frequency - The frequency of recurrence (e.g., 'weekly', 'monthly').
 * @param {String} roomId - The unique identifier for the room/service.
 * 
 * @returns {Object} - An object containing the success message and booking details for each occurrence.
 */
exports.createRecurringBooking = async (startDate, endDate, frequency, roomId) => {
    try {
        // Validate required fields
        if (!startDate || !endDate || !frequency || !roomId) {
            throw new Error('Missing required fields: startDate, endDate, frequency, and roomId are required');
        }

        // Ensure that startDate and endDate are valid dates
        const start = new Date(startDate);
        const end = new Date(endDate);
        if (isNaN(start) || isNaN(end)) {
            throw new Error('Invalid date format. Please provide valid startDate and endDate.');
        }

        // Define a function to get the next date based on the frequency
        const getNextDate = (currentDate) => {
            const nextDate = new Date(currentDate);
            if (frequency === 'weekly') {
                nextDate.setDate(nextDate.getDate() + 7);
            } else if (frequency === 'monthly') {
                nextDate.setMonth(nextDate.getMonth() + 1);
            } else {
                throw new Error('Unsupported frequency. Use "weekly" or "monthly".');
            }
            return nextDate;
        };

        let currentDate = start;
        const bookingDetails = [];

        while (currentDate <= end) {
            // Check availability for each recurring date
            const availability = await exports.checkAvailability(currentDate, currentDate, roomId);
            if (!availability.available) {
                throw new Error(`Conflict detected: ${availability.message}`);
            }

            // Create a booking for each available recurring date
            const booking = new Booking({
                checkInDate: currentDate,
                checkOutDate: currentDate,
                roomId: roomId,
                // Add additional booking information if needed
            });

            await booking.save();
            bookingDetails.push({ bookingId: booking._id, date: currentDate });

            // Move to the next recurring date
            currentDate = getNextDate(currentDate);
        }

        // Respond with a success message containing the booking details for each occurrence
        return {
            success: true,
            message: 'Recurring bookings successfully created.',
            details: bookingDetails
        };

    } catch (error) {
        // Handle errors like conflicting bookings, invalid parameters, or database issues
        return {
            success: false,
            message: `Error creating recurring bookings: ${error.message}`
        };
    }
};

/**
 * Adds a user to the waitlist for a fully booked date range.
 *
 * @param {String} userId - The unique identifier of the user.
 * @param {Date} checkInDate - The starting date of the requested booking.
 * @param {Date} checkOutDate - The ending date of the requested booking.
 * @param {String} roomId - The unique identifier of the room/service.
 *
 * @returns {Object} - An object containing the success message or errors encountered.
 */
exports.addToWaitlist = async (userId, checkInDate, checkOutDate, roomId) => {
    try {
        // Validate required fields
        if (!userId || !checkInDate || !checkOutDate || !roomId) {
            throw new Error('Missing required fields: userId, checkInDate, checkOutDate, and roomId are required.');
        }

        // Ensure that checkInDate and checkOutDate are valid dates
        const checkIn = new Date(checkInDate);
        const checkOut = new Date(checkOutDate);
        if (isNaN(checkIn) || isNaN(checkOut)) {
            throw new Error('Invalid date format. Please provide valid checkInDate and checkOutDate.');
        }

        // Check if the requested period is fully booked
        const existingBookings = await Booking.find({
            roomId: roomId,
            $or: [
                { checkInDate: { $lt: checkOut }, checkOutDate: { $gt: checkIn } }
            ]
        });

        if (existingBookings.length === 0) {
            throw new Error('The requested room is available for booking. No need for a waitlist.');
        }

        // Add the user to the waitlist
        const waitlistEntry = new Waitlist({
            userId: userId,
            roomId: roomId,
            checkInDate: checkIn,
            checkOutDate: checkOut,
            priority: 1 // Example of assigning a default priority
        });

        await waitlistEntry.save();

        return {
            success: true,
            message: 'User has been successfully added to the waitlist.'
        };
    } catch (error) {
        return {
            success: false,
            message: `Error adding user to waitlist: ${error.message}`
        };
    }
};

    - Supporting data 
    - Updating File undefined
    
    Please generate the code for this task, following the instructions and including comments for clarity.
    While creating router for specifict file your have to read supporing file data and create for that 

    **Output Formats**: 

Return dependencies like this `const bcrypt = require('bcrypt');`  in this formate
```dependencies
const bcrypt = require('bcrypt');
```

Ensure this format is consistently followed in responses.
    
User: 


    
Assistant: