@getmicdrop/venue-calendar 3.3.1 → 3.3.2

package/src/lib/utils/api.js

@@ -1,790 +0,0 @@
-import { logger } from '$lib/utils/logger.js';
-
-const API_BASE_URL = "https://get-micdrop.com";
-const PUBLIC_BASE_URL = `${API_BASE_URL}/api/v2/public`;
-
-// Note: Stripe publishable key is now fetched dynamically from the payment intent API response
-// This ensures third-party embeds get the correct key without needing environment variables
-
-/**
- * Create a payment intent for the cart
- * @param {string} cartId - The cart/order UUID
- * @param {Object} quantities - Map of ticketId -> quantity
- * @returns {Promise<{clientSecret: string, ...} | null>}
- */
-export async function createPaymentIntent(cartId, quantities) {
-  try {
-    // Get IP address
-    const ipRes = await fetch('https://api.ipify.org?format=json');
-    const ipData = await ipRes.json();
-    const ip = ipData.ip;
-
-    const res = await fetch(
-      `${PUBLIC_BASE_URL}/orders/${cartId}/payment-intent`,
-      {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-        },
-        credentials: 'include',
-        body: JSON.stringify({
-          IP: ip,
-          productQuantities: quantities,
-        }),
-      }
-    );
-
-    if (!res.ok) {
-      const errorData = await res.json().catch(() => ({}));
-      logger.error('Payment intent creation failed:', errorData);
-      throw new Error(errorData.error || 'Failed to create payment intent');
-    }
-
-    const data = await res.json();
-    logger.debug('create payment intent API response:', data);
-    return data;
-  } catch (err) {
-    logger.error('createPaymentIntent error:', err);
-    return null;
-  }
-}
-
-// Map human-readable timezone strings to IANA timezone identifiers
-function getIANATimezone(tzString) {
-  if (!tzString || tzString === 'NaN') return 'America/Los_Angeles'; // Default to LA
-
-  const tzMap = {
-    'UTC': 'UTC',
-    'California USA': 'America/Los_Angeles',
-    'California': 'America/Los_Angeles',
-    'Los Angeles': 'America/Los_Angeles',
-    'New York': 'America/New_York',
-    'New York USA': 'America/New_York',
-    'Chicago': 'America/Chicago',
-    'Chicago USA': 'America/Chicago',
-    'Denver': 'America/Denver',
-    'Denver USA': 'America/Denver',
-    'Phoenix': 'America/Phoenix',
-    'Phoenix USA': 'America/Phoenix',
-  };
-
-  // Check direct match first
-  if (tzMap[tzString]) return tzMap[tzString];
-
-  // Check if it's already an IANA timezone
-  try {
-    Intl.DateTimeFormat(undefined, { timeZone: tzString });
-    return tzString;
-  } catch (e) {
-    // Not a valid IANA timezone, default to LA
-    return 'America/Los_Angeles';
-  }
-}
-
-export async function fetchAllVenues(orgId) {
-  try {
-    if (!orgId) {
-      logger.warn("fetchAllVenues called without orgId");
-      return [];
-    }
-
-    const response = await fetch(`${PUBLIC_BASE_URL}/venues/organization/${orgId}`);
-
-    if (!response.ok) {
-      logger.error(`Failed to fetch venues: ${response.status} ${response.statusText}`);
-      return [];
-    }
-
-    const venues = await response.json();
-    logger.debug("Venues:", venues);
-    // Ensure we always return an array, even if API returns null/undefined
-    return Array.isArray(venues) ? venues : [];
-  } catch (error) {
-    logger.error("Error fetching venues:", error);
-    return [];
-  }
-}
-
-export async function fetchVenueEvents(venueId) {
-  try {
-    if (!venueId) {
-      logger.warn("fetchVenueEvents called without venueId");
-      return [];
-    }
-
-    const response = await fetch(`${PUBLIC_BASE_URL}/events/venue/${venueId}`);
-
-    if (!response.ok) {
-      logger.error(`Failed to fetch events: ${response.status} ${response.statusText}`);
-      return [];
-    }
-
-    const events = await response.json();
-    // Ensure we always return an array, even if API returns null/undefined
-    return Array.isArray(events) ? events : [];
-  } catch (error) {
-    // Network errors, CORS issues, etc. - return empty array instead of throwing
-    logger.error("Error fetching events:", error);
-    return [];
-  }
-}
-
-/**
- * Fetch events for a specific month (paginated API)
- * @param {number|string} venueId - Venue ID
- * @param {number} year - Year (e.g., 2025)
- * @param {number} month - Month (1-12, NOT 0-indexed)
- * @returns {Promise<{events: Array, pagination: {hasPrevMonth: boolean, hasNextMonth: boolean, prevMonth: {year, month}, nextMonth: {year, month}}}>}
- */
-export async function getMonthEvents(venueId, year, month) {
-  try {
-    if (!venueId) {
-      logger.warn("getMonthEvents called without venueId");
-      return { events: [], pagination: null };
-    }
-
-    const response = await fetch(`${PUBLIC_BASE_URL}/events/venue/${venueId}/month/${year}/${month}`);
-
-    if (!response.ok) {
-      logger.error(`Failed to fetch month events: ${response.status} ${response.statusText}`);
-      return { events: [], pagination: null };
-    }
-
-    const data = await response.json();
-    return {
-      events: Array.isArray(data.events) ? data.events : [],
-      pagination: data.pagination || null,
-      year: data.year,
-      month: data.month
-    };
-  } catch (error) {
-    logger.error("Error fetching month events:", error);
-    return { events: [], pagination: null };
-  }
-}
-
-/**
- * Fetch events for a specific month at org level (all venues under an org)
- * @param {number|string} orgId - Organization ID (userID of org owner)
- * @param {number} year - Year (e.g., 2025)
- * @param {number} month - Month (1-12, NOT 0-indexed)
- * @returns {Promise<{events: Array, pagination: object}>}
- */
-export async function getOrgMonthEvents(orgId, year, month) {
-  try {
-    if (!orgId) {
-      logger.warn("getOrgMonthEvents called without orgId");
-      return { events: [], pagination: null };
-    }
-
-    const response = await fetch(`${PUBLIC_BASE_URL}/events/organization/${orgId}/month/${year}/${month}`);
-
-    if (!response.ok) {
-      logger.error(`Failed to fetch org month events: ${response.status} ${response.statusText}`);
-      return { events: [], pagination: null };
-    }
-
-    const data = await response.json();
-    return {
-      events: Array.isArray(data.events) ? data.events : [],
-      pagination: data.pagination || null,
-      year: data.year,
-      month: data.month
-    };
-  } catch (error) {
-    logger.error("Error fetching org month events:", error);
-    return { events: [], pagination: null };
-  }
-}
-
-export function transformEventData(apiEvent) {
-  // Get the venue's timezone (API returns strings like "California USA" or "UTC")
-  const venueTimezone = getIANATimezone(apiEvent.timeZone);
-
-  // Extract date from startDateTime in the venue's timezone
-  // API returns UTC like "2025-11-30T20:00:00Z" which should display in venue TZ
-  let startDate = '';
-  if (apiEvent.startDateTime) {
-    const dt = new Date(apiEvent.startDateTime);
-    // Format date in the venue's timezone
-    const dateInVenueTZ = dt.toLocaleDateString('en-CA', {
-      timeZone: venueTimezone,
-      year: 'numeric',
-      month: '2-digit',
-      day: '2-digit'
-    });
-    // en-CA gives YYYY-MM-DD format
-    startDate = dateInVenueTZ;
-  }
-
-  // Handle image URLs - prepend DigitalOcean Spaces CDN URL for relative paths
-  let imageUrl = apiEvent.image || apiEvent.imageUrl || apiEvent.image_url || '';
-  if (imageUrl && imageUrl.startsWith('/')) {
-    imageUrl = `https://moxy.sfo3.digitaloceanspaces.com${imageUrl}`;
-  }
-
-  // Calculate scarcity data from available tickets if present
-  // The API may include availableTickets in the list response
-  const tickets = apiEvent.availableTickets || [];
-  const publicTickets = tickets.filter(t => t.salesChannel !== 2); // Exclude "At the door only"
-
-  let totalRemaining = 0;
-  let totalCapacity = 0;
-  let isSoldOut = false;
-
-  if (publicTickets.length > 0) {
-    for (const ticket of publicTickets) {
-      const remaining = ticket.remainingCapacity ?? ticket.quantityRemaining ?? ticket.quantity ?? 0;
-      const capacity = ticket.totalCapacity ?? ticket.quantity ?? remaining;
-      totalRemaining += remaining;
-      totalCapacity += capacity;
-    }
-    // Check if all tickets are sold out
-    isSoldOut = totalRemaining === 0;
-  }
-
-  const transformed = {
-    id: apiEvent.id,
-    name: apiEvent.title || apiEvent.name || '',
-    date: startDate || apiEvent.date || apiEvent.startDate || apiEvent.eventDate || '',
-    image: imageUrl,
-    status: apiEvent.status || 'On Sale',
-    timeline: formatEventTime(apiEvent, venueTimezone),
-    description: apiEvent.description || apiEvent.eventSummary || '',
-    venueId: apiEvent.venueId || apiEvent.venue_id,
-    timeZone: venueTimezone,
-    // Series info for grouping recurring events
-    eventSeriesId: apiEvent.eventSeriesId || null,
-    // Keep raw startDateTime for sorting
-    startDateTime: apiEvent.startDateTime || null,
-    // Scarcity data for browse views
-    ticketsRemaining: totalRemaining,
-    ticketsTotal: totalCapacity,
-    isSoldOut: isSoldOut,
-  };
-
-  return transformed;
-}
-
-function formatEventTime(event, venueTimezone = 'America/Los_Angeles') {
-  // Format time from API datetime strings in the venue's timezone
-  const formatTime = (dateTimeStr) => {
-    if (!dateTimeStr) return '';
-    try {
-      const date = new Date(dateTimeStr);
-      return date.toLocaleTimeString('en-US', {
-        timeZone: venueTimezone,
-        hour: 'numeric',
-        minute: '2-digit',
-        hour12: true
-      });
-    } catch (e) {
-      return '';
-    }
-  };
-
-  const startTime = formatTime(event.startDateTime);
-  const endTime = formatTime(event.endDateTime);
-
-  if (startTime && endTime) {
-    return `${startTime} - ${endTime}`;
-  }
-  if (startTime) {
-    return startTime;
-  }
-
-  // Fallback to old field names if new ones don't exist
-  if (event.startTime && event.endTime) {
-    return `${event.startTime} - ${event.endTime}`;
-  }
-  if (event.startTime) {
-    return event.startTime;
-  }
-
-  return '';
-}
-
-export async function fetchEventDetails(eventId, customFetch = fetch) {
-  try {
-    const response = await customFetch(`${PUBLIC_BASE_URL}/events/${eventId}`);
-
-    if (!response.ok) {
-      throw new Error(`Failed to fetch event details: ${response.status}`);
-    }
-
-    const event = await response.json();
-    return event;
-  } catch (error) {
-    logger.error("Error fetching event details:", error);
-    throw error;
-  }
-}
-
-export async function fetchEventTickets(eventId) {
-  try {
-    const response = await fetch(`${PUBLIC_BASE_URL}/tickets/event/${eventId}`);
-
-    if (!response.ok) {
-      throw new Error(`Failed to fetch tickets: ${response.status}`);
-    }
-
-    const tickets = await response.json();
-    return Array.isArray(tickets) ? tickets : [];
-  } catch (error) {
-    logger.error("Error fetching tickets:", error);
-    throw error;
-  }
-}
-
-/**
- * Validate a promo code for an event via the public API
- * @param {string} eventId - The event ID
- * @param {string} code - The promo code to validate
- * @returns {Promise<{valid: boolean, revealHiddenTickets?: boolean, revealTicketIds?: number[], provideDiscount?: boolean, discountType?: string, amount?: number}>}
- */
-export async function validatePromoCode(eventId, code) {
-  try {
-    // API uses GET with code in URL path: /validatePromoCode/{eventId}/{code}
-    const encodedCode = encodeURIComponent(code);
-    const response = await fetch(`${PUBLIC_BASE_URL}/promo-codes/validate/${eventId}/${encodedCode}`);
-
-    if (!response.ok) {
-      // Invalid code or server error
-      return { valid: false };
-    }
-
-    const result = await response.json();
-    return result;
-  } catch (error) {
-    logger.error("Error validating promo code:", error);
-    return { valid: false };
-  }
-}
-
-/**
- * Check if promo codes are available for an event
- * @param {string} eventId - The event ID
- * @returns {Promise<boolean>} - Whether promo codes exist for this event
- */
-export async function hasPromoCodes(eventId) {
-  try {
-    const response = await fetch(`${PUBLIC_BASE_URL}/promo-codes/check/${eventId}`);
-
-    if (!response.ok) {
-      // If endpoint doesn't exist or errors, default to showing the input
-      return true;
-    }
-
-    const result = await response.json();
-    return result.hasPromoCodes === true;
-  } catch (error) {
-    logger.error("Error checking promo codes availability:", error);
-    // Default to showing promo input if we can't check
-    return true;
-  }
-}
-
-/**
- * Extend the checkout session by 15 minutes
- * @param {string} orderUuid - The order UUID
- * @returns {Promise<{success: boolean, newExpiryTime?: string, remainingExtensions?: number, error?: string}>}
- */
-export async function extendCheckoutSession(orderUuid) {
-  try {
-    const response = await fetch(`${PUBLIC_BASE_URL}/orders/extend-session`, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-      },
-      body: JSON.stringify({ orderUuid }),
-    });
-
-    if (!response.ok) {
-      const errorData = await response.json().catch(() => ({}));
-      return {
-        success: false,
-        error: errorData.error || 'Failed to extend session'
-      };
-    }
-
-    const result = await response.json();
-    return {
-      success: true,
-      newExpiryTime: result.newExpiryTime,
-      remainingExtensions: result.remainingExtensions,
-    };
-  } catch (error) {
-    logger.error("Error extending checkout session:", error);
-    return { success: false, error: 'Network error extending session' };
-  }
-}
-
-/**
- * Get current session status including expiry time
- * @param {string} orderUuid - The order UUID
- * @returns {Promise<{expiresAt?: string, extensionCount?: number, remainingExtensions?: number, canExtend?: boolean, error?: string}>}
- */
-export async function getSessionStatus(orderUuid) {
-  try {
-    const response = await fetch(`${PUBLIC_BASE_URL}/orders/session/${orderUuid}`);
-
-    if (!response.ok) {
-      const errorData = await response.json().catch(() => ({}));
-      return { error: errorData.error || 'No active session found' };
-    }
-
-    const result = await response.json();
-    return {
-      expiresAt: result.expiresAt,
-      extensionCount: result.extensionCount,
-      remainingExtensions: result.remainingExtensions,
-      canExtend: result.canExtend,
-      reservationCount: result.reservationCount,
-    };
-  } catch (error) {
-    logger.error("Error getting session status:", error);
-    return { error: 'Network error getting session status' };
-  }
-}
-
-/**
- * Complete reservation after successful payment
- * @param {string} orderUuid - The order UUID
- * @returns {Promise<{success: boolean, message?: string, error?: string}>}
- */
-export async function completeReservation(orderUuid) {
-  try {
-    const response = await fetch(`${PUBLIC_BASE_URL}/orders/complete/${orderUuid}`, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-      },
-    });
-
-    if (!response.ok) {
-      const errorData = await response.json().catch(() => ({}));
-      return {
-        success: false,
-        error: errorData.error || 'Failed to complete reservation'
-      };
-    }
-
-    const result = await response.json();
-    return {
-      success: true,
-      message: result.message,
-    };
-  } catch (error) {
-    logger.error("Error completing reservation:", error);
-    return { success: false, error: 'Network error completing reservation' };
-  }
-}
-
-/**
- * Cancel reservation and release tickets back to inventory
- * @param {string} orderUuid - The order UUID
- * @returns {Promise<{success: boolean, message?: string, error?: string}>}
- */
-export async function cancelReservation(orderUuid) {
-  try {
-    const response = await fetch(`${PUBLIC_BASE_URL}/orders/cancel/${orderUuid}`, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-      },
-    });
-
-    if (!response.ok) {
-      const errorData = await response.json().catch(() => ({}));
-      return {
-        success: false,
-        error: errorData.error || 'Failed to cancel reservation'
-      };
-    }
-
-    const result = await response.json();
-    return {
-      success: true,
-      message: result.message,
-    };
-  } catch (error) {
-    logger.error("Error cancelling reservation:", error);
-    return { success: false, error: 'Network error cancelling reservation' };
-  }
-}
-
-/**
- * Fetch performers for a public event
- * Uses the new public API endpoint that returns pre-resolved avatar URLs
- * @param {string|number} eventId - The event ID
- * @returns {Promise<{performers: Array<{id: number, stageName: string, displayName: string, avatar: string, order: number}>, showPerformers: boolean}>}
- */
-export async function fetchEventPerformers(eventId) {
-  try {
-    if (!eventId) {
-      logger.warn("fetchEventPerformers called without eventId");
-      return { performers: [], showPerformers: false };
-    }
-
-    const response = await fetch(`${PUBLIC_BASE_URL}/events/${eventId}/performers`);
-
-    if (!response.ok) {
-      logger.error(`Failed to fetch performers: ${response.status} ${response.statusText}`);
-      return { performers: [], showPerformers: false };
-    }
-
-    const data = await response.json();
-    return {
-      performers: Array.isArray(data.performers) ? data.performers : [],
-      showPerformers: data.showPerformers === true,
-    };
-  } catch (error) {
-    logger.error("Error fetching event performers:", error);
-    return { performers: [], showPerformers: false };
-  }
-}
-
-/**
- * Get series occurrences for date selector
- * @param {number} eventSeriesId - The event series ID
- * @returns {Promise<{seriesId?: number, seriesName?: string, occurrences?: Array, error?: string}>}
- */
-export async function getSeriesOccurrences(eventSeriesId) {
-  try {
-    const response = await fetch(`${PUBLIC_BASE_URL}/series/${eventSeriesId}/occurrences`);
-
-    if (!response.ok) {
-      const errorData = await response.json().catch(() => ({}));
-      return { error: errorData.error || 'Event series not found' };
-    }
-
-    const result = await response.json();
-    return {
-      seriesId: result.seriesId,
-      seriesName: result.seriesName,
-      occurrences: result.occurrences || [],
-    };
-  } catch (error) {
-    logger.error("Error fetching series occurrences:", error);
-    return { error: 'Network error fetching series occurrences' };
-  }
-}
-
-/**
- * Check if a password is correct for a password-protected event
- * @param {string} eventId - The event ID
- * @param {string} password - The password attempt
- * @returns {Promise<{valid: boolean}>}
- */
-export async function checkEventPassword(eventId, password) {
-  try {
-    const encodedPassword = encodeURIComponent(password);
-    const response = await fetch(`${PUBLIC_BASE_URL}/events/${eventId}/check-password/${encodedPassword}`);
-
-    if (!response.ok) {
-      return { valid: false };
-    }
-
-    const result = await response.json();
-    // API may return boolean directly or object with valid property
-    if (typeof result === 'boolean') {
-      return { valid: result };
-    }
-    return { valid: result.valid === true || result === true };
-  } catch (error) {
-    logger.error("Error checking event password:", error);
-    return { valid: false };
-  }
-}
-
-export async function testNetworkConnection(orgId = null, venueId = null) {
-  const results = {
-    organization: false,
-    venue: false,
-    timestamp: new Date().toISOString()
-  };
-
-  if (orgId) {
-    try {
-      const orgResponse = await fetch(`${PUBLIC_BASE_URL}/venues/organization/${orgId}`, {
-        method: 'GET',
-        signal: AbortSignal.timeout(5000)
-      });
-      results.organization = orgResponse.ok;
-    } catch (error) {
-      logger.error("Organization API test failed:", error);
-      results.organization = false;
-    }
-  }
-
-  if (venueId) {
-    try {
-      const venueResponse = await fetch(`${PUBLIC_BASE_URL}/events/venue/${venueId}`, {
-        method: 'GET',
-        signal: AbortSignal.timeout(5000)
-      });
-      results.venue = venueResponse.ok;
-    } catch (error) {
-      logger.error("Venue API test failed:", error);
-      results.venue = false;
-    }
-  }
-
-  return results;
-}
-
-/**
- * Compute CTA button state for an event based on its tickets
- * @param {Object} event - The event object with startDateTime, endDateTime
- * @param {Array} tickets - Array of ticket objects
- * @returns {{text: string, disabled: boolean, reason: string}}
- */
-function computeCtaState(event, tickets) {
-  const now = new Date();
-
-  // Check if event is in the past
-  const eventEnd = event.endDateTime || event.startDateTime;
-  if (eventEnd && new Date(eventEnd) < now) {
-    return { text: 'Sales ended', disabled: true, reason: 'event_past' };
-  }
-
-  // Filter to public tickets (exclude "At the door only" - salesChannel = 2)
-  const publicTickets = (tickets || []).filter(t => t.salesChannel !== 2);
-
-  // No public tickets available
-  if (publicTickets.length === 0) {
-    return { text: 'No tickets', disabled: true, reason: 'no_tickets' };
-  }
-
-  // Check ticket statuses
-  let allSoldOut = true;
-  let allSalesEnded = true;
-  let allComingSoon = true;
-  let earliestSalesStart = null;
-
-  for (const ticket of publicTickets) {
-    const salesBegin = ticket.salesBegin || ticket.salesStart || ticket.saleBegin || ticket.onSaleStart;
-    const salesEnd = ticket.salesEnd || ticket.saleEnd || ticket.onSaleEnd;
-    const remaining = ticket.remainingCapacity ?? ticket.quantityRemaining ?? ticket.quantity;
-    const isSoldOut = ticket.soldOut || (remaining !== null && remaining !== undefined && remaining <= 0);
-
-    const isScheduled = salesBegin && new Date(salesBegin) > now;
-    const hasSalesEnded = salesEnd && new Date(salesEnd) < now;
-
-    if (!isSoldOut) allSoldOut = false;
-    if (!hasSalesEnded) allSalesEnded = false;
-    if (!isScheduled) allComingSoon = false;
-
-    if (isScheduled && salesBegin) {
-      const startDate = new Date(salesBegin);
-      if (!earliestSalesStart || startDate < earliestSalesStart) {
-        earliestSalesStart = startDate;
-      }
-    }
-  }
-
-  if (allSalesEnded) {
-    return { text: 'Sales ended', disabled: true, reason: 'sales_ended' };
-  }
-
-  if (allSoldOut) {
-    return { text: 'Sold out', disabled: true, reason: 'sold_out' };
-  }
-
-  if (allComingSoon && earliestSalesStart) {
-    // Always show month + day + time format: "Dec 19 12:04 PM"
-    const dateText = earliestSalesStart.toLocaleDateString('en-US', { month: 'short', day: 'numeric' });
-    const timeText = earliestSalesStart.toLocaleTimeString('en-US', { hour: 'numeric', minute: '2-digit', hour12: true });
-    return { text: `On sale ${dateText} ${timeText}`, disabled: true, reason: 'coming_soon' };
-  }
-
-  // Default: tickets available
-  return { text: 'Get tickets', disabled: false, reason: 'available' };
-}
-
-/**
- * Fetch all occurrences of an event series with CTA state
- * Uses the optimized getSeriesOccurrences API first, falls back to listAllEvents if needed
- * @param {number} eventSeriesId - The event series ID
- * @param {number} venueId - The venue ID to fetch events from (used for fallback)
- * @returns {Promise<Array<{id: number, startDateTime: string, slug: string, name: string, ctaState: {text: string, disabled: boolean, reason: string}}>>}
- */
-export async function fetchSeriesOccurrences(eventSeriesId, venueId) {
-  if (!eventSeriesId || eventSeriesId <= 0) {
-    return [];
-  }
-
-  try {
-    // Try the new optimized API first
-    const seriesResult = await getSeriesOccurrences(eventSeriesId);
-
-    if (!seriesResult.error && seriesResult.occurrences?.length > 0) {
-      // Map API response to expected format
-      // The API returns: { id, slug, startDateTime, endDateTime, ctaState }
-      return seriesResult.occurrences
-        .map(occ => ({
-          id: occ.id,
-          name: occ.name || occ.title || '',
-          slug: occ.slug,
-          startDateTime: occ.startDateTime,
-          endDateTime: occ.endDateTime,
-          ctaState: occ.ctaState || computeCtaState(occ, occ.availableTickets || [])
-        }))
-        .sort((a, b) => new Date(a.startDateTime) - new Date(b.startDateTime));
-    }
-
-    // Fallback to the old method if new API fails or returns empty
-    if (!venueId) {
-      return [];
-    }
-
-    // Use existing listAllEvents API and filter by series ID
-    const response = await fetch(`${PUBLIC_BASE_URL}/events/venue/${venueId}`);
-
-    if (!response.ok) {
-      throw new Error(`Failed to fetch venue events: ${response.status}`);
-    }
-
-    const allEvents = await response.json();
-
-    // Filter events that belong to this series
-    const seriesEvents = allEvents.filter(e => e.eventSeriesId === eventSeriesId);
-
-    // For each event in the series, fetch full details (tickets are included in availableTickets)
-    const occurrences = await Promise.all(
-      seriesEvents.map(async (event) => {
-        try {
-          const eventResponse = await fetch(`${PUBLIC_BASE_URL}/events/${event.id}`);
-          if (!eventResponse.ok) return null;
-
-          const fullEvent = await eventResponse.json();
-          // Tickets are included in the event response as availableTickets
-          const tickets = fullEvent.availableTickets || [];
-
-          // Compute CTA state based on event and ticket data
-          const ctaState = computeCtaState(fullEvent, tickets);
-
-          return {
-            id: fullEvent.id,
-            name: fullEvent.name,
-            slug: fullEvent.slug,
-            startDateTime: fullEvent.startDateTime,
-            endDateTime: fullEvent.endDateTime,
-            ctaState
-          };
-        } catch {
-          return null;
-        }
-      })
-    );
-
-    // Filter out nulls and sort by start date
-    return occurrences
-      .filter(Boolean)
-      .sort((a, b) => new Date(a.startDateTime) - new Date(b.startDateTime));
-  } catch (error) {
-    logger.error("Error fetching series occurrences:", error);
-    return [];
-  }
-}
-