Use Cases & Examples

// Complete workflow: Fetch resources → Display form → Create event

const BookingFormHandler = {
  async initialize() {
    // Fetch available resources
    const [sources, spaces, statuses] = await Promise.all([
      this.fetchSources(),
      this.fetchSpaces(),
      this.fetchStatuses()
    ]);

    // Populate form dropdowns
    this.populateDropdown('source-select', sources);
    this.populateDropdown('space-select', spaces);
    this.populateDropdown('status-select', statuses);
  },

  async fetchSources() {
    const response = await fetch('https://api.bookingshake.io/api/sources', {
      headers: {
        'Authorization': `Bearer ${process.env.BOOKINGSHAKE_API_KEY}`
      }
    });
    return await response.json();
  },

  async fetchSpaces() {
    const response = await fetch('https://api.bookingshake.io/api/spaces', {
      headers: {
        'Authorization': `Bearer ${process.env.BOOKINGSHAKE_API_KEY}`
      }
    });
    return await response.json();
  },

  async fetchStatuses() {
    const response = await fetch('https://api.bookingshake.io/api/status', {
      headers: {
        'Authorization': `Bearer ${process.env.BOOKINGSHAKE_API_KEY}`
      }
    });
    return await response.json();
  },

  populateDropdown(selectId, items) {
    const select = document.getElementById(selectId);
    items.forEach(item => {
      const option = document.createElement('option');
      option.value = item.value;
      option.textContent = item.label;
      select.appendChild(option);
    });
  },

  async submitBooking(formData) {
    const response = await fetch('https://api.bookingshake.io/api/events/create', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${process.env.BOOKINGSHAKE_API_KEY}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        bookings: [{
          date: formData.date,
          startTime: formData.startTime,
          endTime: formData.endTime,
          pax: formData.pax,
          space_id: formData.spaceId,
          event_type: formData.eventType
        }],
        contact: {
          firstname: formData.firstname,
          lastname: formData.lastname,
          email: formData.email,
          phone_number: formData.phone
        },
        source_slug: formData.sourceSlug
      })
    });

    return await response.json();
  }
};

// Initialize when page loads
document.addEventListener('DOMContentLoaded', () => {
  BookingFormHandler.initialize();
});

class BookingShakeAPI {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.baseURL = 'https://api.bookingshake.io/api';
  }

  async request(endpoint, options = {}) {
    const url = `${this.baseURL}${endpoint}`;
    const headers = {
      'Authorization': `Bearer ${this.apiKey}`,
      'Content-Type': 'application/json',
      ...options.headers
    };

    try {
      const response = await fetch(url, {
        ...options,
        headers
      });

      const data = await response.json();

      if (!response.ok) {
        throw new Error(`API Error: ${data.message}`);
      }

      return data;
    } catch (error) {
      console.error('BookingShake API request failed:', error);
      throw error;
    }
  }

  // Validate date format (DD-MM-YYYY)
  validateDate(dateString) {
    const regex = /^\d{2}-\d{2}-\d{4}$/;
    if (!regex.test(dateString)) {
      throw new Error('Invalid date format. Use DD-MM-YYYY');
    }
    return true;
  }

  // Validate time format (HH:mm)
  validateTime(timeString) {
    const regex = /^\d{2}:\d{2}$/;
    if (!regex.test(timeString)) {
      throw new Error('Invalid time format. Use HH:mm');
    }
    return true;
  }

  async getSources() {
    return this.request('/sources');
  }

  async getSpaces() {
    return this.request('/spaces');
  }

  async getStatuses() {
    return this.request('/status');
  }

  async getFields() {
    return this.request('/fields');
  }

  async createEvent(bookingData) {
    // Validate input
    bookingData.bookings.forEach(booking => {
      this.validateDate(booking.date);
      this.validateTime(booking.startTime);
      if (booking.endTime) {
        this.validateTime(booking.endTime);
      }
      if (!booking.pax) {
        throw new Error('Number of guests (pax) is required');
      }
    });

    if (!bookingData.contact) {
      throw new Error('Contact information is required');
    }

    if (!bookingData.contact.contact_id) {
      if (!bookingData.contact.firstname || !bookingData.contact.lastname || !bookingData.contact.email) {
        throw new Error('Contact must have firstname, lastname, and email');
      }
    }

    // Make API request
    return this.request('/events/create', {
      method: 'POST',
      body: JSON.stringify(bookingData)
    });
  }
}

// Usage example
const api = new BookingShakeAPI(process.env.BOOKINGSHAKE_API_KEY);

async function processBooking(formData) {
  try {
    // Get available resources
    const spaces = await api.getSpaces();
    console.log('Available spaces:', spaces);

    // Create the event
    const result = await api.createEvent({
      bookings: [{
        date: formData.date,
        startTime: formData.startTime,
        endTime: formData.endTime,
        pax: formData.guestCount,
        space_id: formData.selectedSpace,
        event_type: formData.eventType
      }],
      contact: {
        firstname: formData.firstname,
        lastname: formData.lastname,
        email: formData.email,
        phone_number: formData.phone
      },
      source_slug: 'website'
    });

    console.log('Event created successfully:', result);
    return result;

  } catch (error) {
    console.error('Booking failed:', error.message);
    throw error;
  }
}