all

WEBHOOK_EVENTS_FEATURE.md

@@ -0,0 +1,156 @@
+# WeBook Events Feature
+
+## Overview
+The WeBook Events feature allows users to browse and search for events from the WeBook platform directly through the Telegram bot. Users can filter events by date, price, and other criteria.
+
+## Features
+
+### 🎭 Event Browsing
+- Browse events from WeBook platform
+- View event details including title, date, location, price, and venue
+- Paginated results (5 events per page)
+
+### 🔍 Filtering Options
+- **Date Filters:**
+  - Today's events
+  - Tomorrow's events
+  - This week's events
+
+- **Price Filters:**
+  - Free events only
+  - Paid events only
+
+- **Clear Filters:** Reset all applied filters
+
+### 📱 User Interface
+- Inline keyboard navigation
+- Pagination controls (Previous/Next)
+- Active filters display
+- Back to main menu option
+
+## Technical Implementation
+
+### Files Modified/Created
+
+1. **`src/bots/handlers/webookHandlers.ts`** - Main handler for WeBook events
+2. **`src/bots/utils/keyboardUtils.ts`** - Updated to include WeBook Events button
+3. **`src/bots/handlers/index.ts`** - Added WeBook handlers setup
+4. **`src/bots/utils/messageManager.ts`** - Added error messages
+
+### Key Components
+
+#### WeBook API Integration
+- Uses the existing `WeBookAPI` class from `src/webook/webookApi.ts`
+- Fetches events with filtering and pagination
+- Handles API errors gracefully
+
+#### User State Management
+- Stores user pagination state and filters
+- Maintains state per user (telegram ID)
+- Resets to first page when applying new filters
+
+#### Event Display Format
+```
+🎭 WeBook Events
+
+📊 Showing 1-5 of 25 events
+
+🔍 Active Filters: Today, Free Events
+
+1. Event Title
+   Event Subtitle
+   📅 Mon, Jan 15, 2024
+   📍 Riyadh
+   💰 Free
+   🎪 Venue Name
+
+2. Another Event
+   ...
+```
+
+### Keyboard Layout
+
+#### Main Menu (Logged In)
+```
+🔍 Browse Services
+🎭 WeBook Events
+[Profile] [Change Language]
+[Top Up Balance] [History]
+[Back]
+```
+
+#### Events Browser
+```
+[📅 Today] [📅 Tomorrow] [📅 This Week]
+[🆓 Free] [💰 Paid] [🧹 Clear Filters]
+[⬅️ Previous] [📄 1/5] [Next ➡️]
+[🔙 Back to Menu]
+```
+
+## Usage
+
+1. **Access Events:** Click "🎭 WeBook Events" from the main menu
+2. **Browse Events:** View events with pagination
+3. **Apply Filters:** Use filter buttons to narrow results
+4. **Clear Filters:** Reset to show all events
+5. **Navigate:** Use Previous/Next buttons to browse pages
+
+## Error Handling
+
+- **API Errors:** Graceful fallback with user-friendly messages
+- **Invalid States:** Automatic state reset and recovery
+- **Network Issues:** Retry mechanism and error notifications
+
+## Configuration
+
+### Default Settings
+- **Country Code:** SA (Saudi Arabia)
+- **Events Per Page:** 5
+- **Default Language:** Arabic (ar-SA)
+
+### Customization
+- Modify `EVENTS_PER_PAGE` constant in `webookHandlers.ts`
+- Update default filters in `handleWeBookEventsAction`
+- Add new filter types in `handleWeBookFilterAction`
+
+## Future Enhancements
+
+- [ ] Category-based filtering
+- [ ] Location-based filtering
+- [ ] Event booking integration
+- [ ] Event reminders
+- [ ] Favorite events
+- [ ] Event sharing
+- [ ] Advanced search with text input
+
+## Dependencies
+
+- `telegraf` - Telegram bot framework
+- `axios` - HTTP client for API calls
+- `src/webook/webookApi.ts` - WeBook API integration
+
+## Testing
+
+To test the feature:
+
+1. Start the bot
+2. Login to the bot
+3. Click "🎭 WeBook Events" from the main menu
+4. Test pagination and filtering
+5. Verify error handling with network issues
+
+## Troubleshooting
+
+### Common Issues
+
+1. **No events showing:** Check WeBook API connectivity
+2. **Filters not working:** Verify filter logic in handlers
+3. **Pagination issues:** Check user state management
+4. **Keyboard not responding:** Verify action handlers setup
+
+### Debug Steps
+
+1. Check bot logs for errors
+2. Verify WeBook API responses
+3. Test individual handler functions
+4. Check user state persistence 

db/get.sh

@@ -0,0 +1 @@
+pg_dump "postgresql://postgres.bxfyodnvfroddubzxgyj:009988Ppooii@aws-0-us-west-1.pooler.supabase.com:5432/postgres"   --no-owner   --format=plain   --file=full_backup.sql

db/push.sh

@@ -0,0 +1 @@
+psql "postgresql://postgres.aoptpqvwquunkmpihygt:009988Ppooii@aws-0-eu-north-1.pooler.supabase.com:5432/postgres" < full_backup.sql

src/bots/handlers/index.ts

@@ -5,6 +5,7 @@ import { setupHistoryHandlers } from './historyHandlers';
 import { setupBalanceHandlers } from './balanceHandlers';
 import { setupLanguageHandlers } from './languageHandlers';
 import { setupProfileHandlers } from './profileHandlers';
+import { setupWeBookHandlers } from './webookHandlers';
 import { handleGiftAmountInput, handleGiftEmailInput, giftStates, handleGiftBalanceAction } from './giftHandlers';
 import { BotContext } from '../types/botTypes';
 import type { ParseMode } from 'telegraf/types';
@@ -17,6 +18,7 @@ export const setupCallbackHandlers = (bot: any) => {
   setupBalanceHandlers(bot);
   setupLanguageHandlers(bot);
   setupProfileHandlers(bot);
+  setupWeBookHandlers(bot);
 
   bot.action('gift_balance', async (ctx: BotContext) => {
     const result = await handleGiftBalanceAction(ctx);

src/bots/handlers/webookHandlers.ts

@@ -0,0 +1,336 @@
+import { BotContext } from "../types/botTypes";
+import { createLogger } from '../../utils/logger';
+import { callbackReplyHandler } from "../utils/handlerUtils";
+import { messageManager } from "../utils/messageManager";
+import { webookAPI, EventFilters } from '../../webook/webookApi';
+import { Markup } from "telegraf";
+import { getBackToMainMenuButton, getLoggedInMenuKeyboard } from "../utils/keyboardUtils";
+
+const logger = createLogger('WeBookHandlers');
+
+// Store user states for pagination and filters
+const userStates = new Map<number, {
+  page: number;
+  filters: EventFilters;
+  totalEvents: number;
+}>();
+
+const EVENTS_PER_PAGE = 5;
+
+export const setupWeBookHandlers = (bot: any) => {
+  bot.action('webook_events', callbackReplyHandler(handleWeBookEventsAction));
+  bot.action(/^webook_page_(\d+)$/, callbackReplyHandler(handleWeBookPageAction));
+  bot.action(/^webook_filter_(.+)$/, callbackReplyHandler(handleWeBookFilterAction));
+  bot.action('webook_back_to_menu', callbackReplyHandler(handleWeBookBackToMenuAction));
+  bot.action('webook_clear_filters', callbackReplyHandler(handleWeBookClearFiltersAction));
+};
+
+export const handleWeBookEventsAction = async (ctx: BotContext) => {
+  try {
+    const telegramId = ctx.from?.id;
+    if (!telegramId) {
+      return {
+        message: messageManager.getMessage('error_user_not_found'),
+        options: getBackToMainMenuButton()
+      };
+    }
+
+    // Initialize user state
+    userStates.set(telegramId, {
+      page: 0,
+      filters: { country_code: 'SA', limit: EVENTS_PER_PAGE },
+      totalEvents: 0
+    });
+
+    return await fetchAndDisplayEvents(telegramId, 0);
+  } catch (error: any) {
+    logger.error(`Error in WeBook events action: ${error.message}`);
+    return {
+      message: messageManager.getMessage('error_general'),
+      options: getBackToMainMenuButton()
+    };
+  }
+};
+
+export const handleWeBookPageAction = async (ctx: BotContext) => {
+  try {
+    const telegramId = ctx.from?.id;
+    if (!telegramId) {
+      return {
+        message: messageManager.getMessage('error_user_not_found'),
+        options: getBackToMainMenuButton()
+      };
+    }
+
+    const match = ctx.match;
+    if (!match) {
+      return {
+        message: messageManager.getMessage('error_invalid_page'),
+        options: getBackToMainMenuButton()
+      };
+    }
+
+    const page = parseInt(match[1]);
+    return await fetchAndDisplayEvents(telegramId, page);
+  } catch (error: any) {
+    logger.error(`Error in WeBook page action: ${error.message}`);
+    return {
+      message: messageManager.getMessage('error_general'),
+      options: getBackToMainMenuButton()
+    };
+  }
+};
+
+export const handleWeBookFilterAction = async (ctx: BotContext) => {
+  try {
+    const telegramId = ctx.from?.id;
+    if (!telegramId) {
+      return {
+        message: messageManager.getMessage('error_user_not_found'),
+        options: getBackToMainMenuButton()
+      };
+    }
+
+    const match = ctx.match;
+    if (!match) {
+      return {
+        message: messageManager.getMessage('error_invalid_filter'),
+        options: getBackToMainMenuButton()
+      };
+    }
+
+    const filterType = match[1];
+    const userState = userStates.get(telegramId);
+    if (!userState) {
+      return {
+        message: messageManager.getMessage('error_user_state_not_found'),
+        options: getBackToMainMenuButton()
+      };
+    }
+
+    // Apply filter based on type
+    switch (filterType) {
+      case 'today':
+        userState.filters.date_filter = 'today';
+        break;
+      case 'tomorrow':
+        userState.filters.date_filter = 'tomorrow';
+        break;
+      case 'this_week':
+        userState.filters.date_filter = 'this_week';
+        break;
+      case 'free':
+        userState.filters.price_max = 0;
+        break;
+      case 'paid':
+        userState.filters.price_min = 1;
+        break;
+      default:
+        // Handle category filters
+        if (filterType.startsWith('cat_')) {
+          const category = filterType.replace('cat_', '');
+          userState.filters.category = category;
+        }
+    }
+
+    userState.page = 0; // Reset to first page when applying filter
+    userStates.set(telegramId, userState);
+
+    return await fetchAndDisplayEvents(telegramId, 0);
+  } catch (error: any) {
+    logger.error(`Error in WeBook filter action: ${error.message}`);
+    return {
+      message: messageManager.getMessage('error_general'),
+      options: getBackToMainMenuButton()
+    };
+  }
+};
+
+export const handleWeBookClearFiltersAction = async (ctx: BotContext) => {
+  try {
+    const telegramId = ctx.from?.id;
+    if (!telegramId) {
+      return {
+        message: messageManager.getMessage('error_user_not_found'),
+        options: getBackToMainMenuButton()
+      };
+    }
+
+    // Reset user state to default
+    userStates.set(telegramId, {
+      page: 0,
+      filters: { country_code: 'SA', limit: EVENTS_PER_PAGE },
+      totalEvents: 0
+    });
+
+    return await fetchAndDisplayEvents(telegramId, 0);
+  } catch (error: any) {
+    logger.error(`Error in WeBook clear filters action: ${error.message}`);
+    return {
+      message: messageManager.getMessage('error_general'),
+      options: getBackToMainMenuButton()
+    };
+  }
+};
+
+export const handleWeBookBackToMenuAction = async (ctx: BotContext) => {
+  return {
+    message: messageManager.getMessage('main_menu_welcome_back').replace('{name}', ctx.from?.first_name || 'User'),
+    options: getLoggedInMenuKeyboard()
+  };
+};
+
+async function fetchAndDisplayEvents(telegramId: number, page: number) {
+  try {
+    const userState = userStates.get(telegramId);
+    if (!userState) {
+      return {
+        message: messageManager.getMessage('error_user_state_not_found'),
+        options: getBackToMainMenuButton()
+      };
+    }
+
+    // Update page and calculate skip
+    userState.page = page;
+    const skip = page * EVENTS_PER_PAGE;
+    const filters = { ...userState.filters, skip, limit: EVENTS_PER_PAGE };
+
+    // Fetch events from WeBook API
+    const response = await webookAPI.getEvents(filters);
+    const events = response.data.eventCollection.items;
+    const total = response.data.eventCollection.total;
+
+    userState.totalEvents = total;
+    userStates.set(telegramId, userState);
+
+    if (events.length === 0) {
+      return {
+        message: '🎭 No events found with the current filters.\n\nTry adjusting your search criteria or clearing filters.',
+        options: getWeBookEventsKeyboard(page, total, userState.filters)
+      };
+    }
+
+    // Build events message
+    let message = `🎭 <b>WeBook Events</b>\n\n`;
+    message += `📊 Showing ${skip + 1}-${Math.min(skip + events.length, total)} of ${total} events\n\n`;
+
+    // Add active filters info
+    const activeFilters = getActiveFiltersText(userState.filters);
+    if (activeFilters) {
+      message += `🔍 <b>Active Filters:</b> ${activeFilters}\n\n`;
+    }
+
+    // Display events
+    events.forEach((event, index) => {
+      const eventNumber = skip + index + 1;
+      message += `${eventNumber}. <b>${event.title || 'Untitled Event'}</b>\n`;
+      
+      if (event.subtitle) {
+        message += `   ${event.subtitle}\n`;
+      }
+      
+      if (event.schedule?.openDateTime) {
+        const eventDate = new Date(event.schedule.openDateTime).toLocaleDateString('en-US', {
+          weekday: 'short',
+          year: 'numeric',
+          month: 'short',
+          day: 'numeric'
+        });
+        message += `   📅 ${eventDate}\n`;
+      }
+      
+      if (event.location?.city) {
+        message += `   📍 ${event.location.city}\n`;
+      }
+      
+      if (event.startingPrice !== undefined) {
+        const priceText = event.startingPrice === 0 ? 'Free' : `${event.startingPrice} ${event.currencyCode || 'SAR'}`;
+        message += `   💰 ${priceText}\n`;
+      }
+      
+      if (event.zone?.title) {
+        message += `   🎪 ${event.zone.title}\n`;
+      }
+      
+      message += '\n';
+    });
+
+    return {
+      message,
+      options: getWeBookEventsKeyboard(page, total, userState.filters)
+    };
+  } catch (error: any) {
+    logger.error(`Error fetching WeBook events: ${error.message}`);
+    return {
+      message: '❌ Error fetching events. Please try again later.',
+      options: getBackToMainMenuButton()
+    };
+  }
+}
+
+function getWeBookEventsKeyboard(page: number, total: number, filters: EventFilters) {
+  const buttons = [];
+  const totalPages = Math.ceil(total / EVENTS_PER_PAGE);
+
+  // Filter buttons
+  const filterRow = [];
+  filterRow.push(Markup.button.callback('📅 Today', 'webook_filter_today'));
+  filterRow.push(Markup.button.callback('📅 Tomorrow', 'webook_filter_tomorrow'));
+  filterRow.push(Markup.button.callback('📅 This Week', 'webook_filter_this_week'));
+  buttons.push(filterRow);
+
+  const priceRow = [];
+  priceRow.push(Markup.button.callback('🆓 Free', 'webook_filter_free'));
+  priceRow.push(Markup.button.callback('💰 Paid', 'webook_filter_paid'));
+  priceRow.push(Markup.button.callback('🧹 Clear Filters', 'webook_clear_filters'));
+  buttons.push(priceRow);
+
+  // Pagination buttons
+  const paginationRow = [];
+  if (page > 0) {
+    paginationRow.push(Markup.button.callback('⬅️ Previous', `webook_page_${page - 1}`));
+  }
+  
+  paginationRow.push(Markup.button.callback(`📄 ${page + 1}/${totalPages}`, 'noop'));
+  
+  if (page < totalPages - 1) {
+    paginationRow.push(Markup.button.callback('Next ➡️', `webook_page_${page + 1}`));
+  }
+  
+  if (paginationRow.length > 0) {
+    buttons.push(paginationRow);
+  }
+
+  // Back button
+  buttons.push([Markup.button.callback('🔙 Back to Menu', 'webook_back_to_menu')]);
+
+  return Markup.inlineKeyboard(buttons);
+}
+
+function getActiveFiltersText(filters: EventFilters): string {
+  const activeFilters = [];
+  
+  if (filters.date_filter) {
+    const dateMap = {
+      'today': 'Today',
+      'tomorrow': 'Tomorrow',
+      'this_week': 'This Week'
+    };
+    activeFilters.push(dateMap[filters.date_filter]);
+  }
+  
+  if (filters.price_min !== undefined && filters.price_min > 0) {
+    activeFilters.push('Paid Events');
+  }
+  
+  if (filters.price_max !== undefined && filters.price_max === 0) {
+    activeFilters.push('Free Events');
+  }
+  
+  if (filters.category) {
+    const category = Array.isArray(filters.category) ? filters.category[0] : filters.category;
+    activeFilters.push(`Category: ${category}`);
+  }
+  
+  return activeFilters.length > 0 ? activeFilters.join(', ') : '';
+} 

src/bots/utils/keyboardUtils.ts

@@ -22,6 +22,7 @@ export const getMainMenuKeyboard = () => {
 export const getLoggedInMenuKeyboard = () => {
   return Markup.inlineKeyboard([
     [Markup.button.callback('🔍 Browse Services', 'browse_services')],
+    [Markup.button.callback('🎭 WeBook Events', 'webook_events')],
     [
       Markup.button.callback(messageManager.getMessage('btn_profile'), 'profile'),
       Markup.button.callback(messageManager.getMessage('btn_change_language'), 'change_language')

src/bots/utils/messageManager.ts

@@ -98,6 +98,26 @@ class MessageManager {
       'no_affordable_products': {
         ar_value: 'عذراً، لا توجد منتجات يمكنك شراؤها برصيدك الحالي ({balance}).',
         en_value: 'Sorry, no products can be bought with your current balance ({balance}).'
+      },
+      'error_user_not_found': {
+        ar_value: '❌ لم يتم العثور على معلومات المستخدم.',
+        en_value: '❌ User information not found.'
+      },
+      'error_invalid_page': {
+        ar_value: '❌ رقم الصفحة غير صحيح.',
+        en_value: '❌ Invalid page number.'
+      },
+      'error_invalid_filter': {
+        ar_value: '❌ نوع الفلتر غير صحيح.',
+        en_value: '❌ Invalid filter type.'
+      },
+      'error_user_state_not_found': {
+        ar_value: '❌ لم يتم العثور على حالة المستخدم.',
+        en_value: '❌ User state not found.'
+      },
+      'error_general': {
+        ar_value: '❌ حدث خطأ. يرجى المحاولة مرة أخرى.',
+        en_value: '❌ An error occurred. Please try again.'
       }
     };
 

src/index.ts

@@ -37,4 +37,4 @@ startServer();
 // To use the WeBook main function, uncomment the following line:
 webookMain().catch(e => { console.error('WeBook Fatal error:', e); });
 
-// handleAddTelegrafBot("049a92c4-7654-43f6-8e6f-7ff5cce78995")
+// handleAddTelegrafBot("1e186256-fdd6-453f-8344-fd824660b8bd")

src/webook/main.ts

@@ -4,7 +4,7 @@ import { WeBookBooking } from './book';
 export async function main() {
   const email = 'mfoud444@gmail.com'; // Replace with your email
   const password = '009988Ppooii@@@@'; // Replace with your password
-  const eventUrl = 'https://webook.com/en/event/your-event-id'; // Replace with your event URL
+  const eventUrl = 'https://webook.com/en/events/ewc-opening-ceremony-2025-tickets/book'; // Replace with your event URL
 
   const login = new WeBookLogin(email, password);
   const page = await login.login();
@@ -13,11 +13,11 @@ export async function main() {
     process.exit(1);
   }
 
-  // const booking = new WeBookBooking(page);
-  // const booked = await booking.bookEvent(eventUrl);
-  // if (booked) {
-  //   console.info('Booking succeeded!');
-  // } else {
-  //   console.error('Booking failed.');
-  // }
+  const booking = new WeBookBooking(page);
+  const booked = await booking.bookEvent(eventUrl);
+  if (booked) {
+    console.info('Booking succeeded!');
+  } else {
+    console.error('Booking failed.');
+  }
 } 

src/webook/webookApi.ts

@@ -0,0 +1,350 @@
+import axios, { AxiosResponse } from 'axios';
+
+// Type definitions
+export interface EventFilter {
+  visibility_not?: string;
+  AND?: any[];
+  OR?: any[];
+}
+
+export interface EventSchedule {
+  title?: string;
+  openTitle?: string;
+  openDateTime?: string;
+  closeDateTime?: string;
+  openScheduleText?: string;
+}
+
+export interface EventLocation {
+  title?: string;
+  address?: string;
+  city?: string;
+  countryCode?: string;
+  seactionHeader?: string;
+  location?: {
+    lat: number;
+    lon: number;
+  };
+  banner?: {
+    title?: string;
+    sys?: {
+      id: string;
+      publishedAt: string;
+    };
+    url?: string;
+    width?: number;
+    height?: number;
+    contentType?: string;
+  };
+  accessibility?: any;
+}
+
+export interface EventZone {
+  id?: string;
+  slug?: string;
+  title?: string;
+  zoneLogo?: {
+    title?: string;
+    sys?: {
+      id: string;
+      publishedAt: string;
+    };
+    url?: string;
+    width?: number;
+    height?: number;
+    contentType?: string;
+  };
+  sponsorLogo?: {
+    title?: string;
+    sys?: {
+      id: string;
+      publishedAt: string;
+    };
+    url?: string;
+    width?: number;
+    height?: number;
+    contentType?: string;
+  };
+}
+
+export interface EventCategory {
+  id?: string;
+  title?: string;
+  slug?: string;
+}
+
+export interface EventImage {
+  title?: string;
+  sys?: {
+    id: string;
+    publishedAt: string;
+  };
+  url?: string;
+  width?: number;
+  height?: number;
+  contentType?: string;
+}
+
+export interface Event {
+  __typename?: string;
+  sys?: {
+    id: string;
+  };
+  id?: string;
+  title?: string;
+  subtitle?: string;
+  slug?: string;
+  ticketingUrlSlug?: string;
+  image11?: EventImage;
+  image31?: EventImage;
+  startingPrice?: number;
+  currencyCode?: string;
+  schedule?: EventSchedule;
+  isStreamingEvent?: boolean;
+  zoneEntryIncluded?: boolean;
+  streamingUrl?: string;
+  buttonLabel?: string;
+  cardButtonLabel?: string;
+  eventType?: string;
+  buttonLink?: string;
+  zone?: EventZone;
+  location?: EventLocation;
+  category?: EventCategory;
+  isComingSoon?: boolean;
+  organizationSlug?: string;
+  carousalCollection?: {
+    items?: EventImage[];
+  };
+}
+
+export interface EventCollection {
+  total: number;
+  items: Event[];
+}
+
+export interface GraphQLResponse {
+  data: {
+    eventCollection: EventCollection;
+  };
+}
+
+export interface EventFilters {
+  category?: string | string[];
+  date_filter?: 'today' | 'tomorrow' | 'this_week';
+  price_min?: number;
+  price_max?: number;
+  zones?: string[];
+  country_code?: string;
+  limit?: number;
+  skip?: number;
+}
+
+export class WeBookAPI {
+  private url: string = "https://cdn.webook.com/";
+  private headers = {
+    "Accept": "*/*",
+    "Accept-Encoding": "gzip, deflate, br, zstd",
+    "Accept-Language": "en-US,en;q=0.9,ar;q=0.8",
+    "Content-Type": "application/json",
+    "Origin": "https://webook.com",
+    "Referer": "https://webook.com/",
+    "User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
+  };
+
+  private getEventsPayload(filters: EventFilters = {}): any {
+    const {
+      category,
+      date_filter,
+      price_min,
+      price_max,
+      zones,
+      country_code = "SA",
+      limit = 20,
+      skip = 0
+    } = filters;
+
+    const now = new Date();
+    const tomorrow = new Date(now.getTime() + 24 * 60 * 60 * 1000);
+    const endOfWeek = new Date(now.getTime() + 7 * 24 * 60 * 60 * 1000);
+
+    // Construct Date Filter Clause
+    const dateScheduleOrClauses: any[] = [];
+
+    // Add clause for events without close date or ending from now onwards
+    const startOfToday = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+    dateScheduleOrClauses.push({
+      "OR": [
+        { "schedule": { "closeDateTime_exists": false } },
+        { "schedule": { "closeDateTime_gte": startOfToday.toISOString() } }
+      ]
+    });
+
+    // Add specific date range clause based on date_filter
+    let dateRangeAndClause: any = {};
+    if (date_filter === 'today') {
+      const startOfDay = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+      const endOfDay = new Date(now.getFullYear(), now.getMonth(), now.getDate(), 23, 59, 59, 999);
+      dateRangeAndClause = {
+        "AND": [
+          { "schedule": { "openDateTime_lte": endOfDay.toISOString() } },
+          { "schedule": { "closeDateTime_gte": startOfDay.toISOString() } }
+        ]
+      };
+    } else if (date_filter === 'tomorrow') {
+      const tomorrowStart = new Date(tomorrow.getFullYear(), tomorrow.getMonth(), tomorrow.getDate());
+      const tomorrowEnd = new Date(tomorrow.getFullYear(), tomorrow.getMonth(), tomorrow.getDate(), 23, 59, 59, 999);
+      dateRangeAndClause = {
+        "AND": [
+          { "schedule": { "openDateTime_lte": tomorrowEnd.toISOString() } },
+          { "schedule": { "closeDateTime_gte": tomorrowStart.toISOString() } }
+        ]
+      };
+    } else if (date_filter === 'this_week') {
+      const startOfWeek = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+      const endOfWeekDate = new Date(endOfWeek.getFullYear(), endOfWeek.getMonth(), endOfWeek.getDate(), 23, 59, 59, 999);
+      dateRangeAndClause = {
+        "AND": [
+          { "schedule": { "openDateTime_lte": endOfWeekDate.toISOString() } },
+          { "schedule": { "closeDateTime_gte": startOfWeek.toISOString() } }
+        ]
+      };
+    }
+
+    if (Object.keys(dateRangeAndClause).length > 0) {
+      dateScheduleOrClauses.push(dateRangeAndClause);
+    }
+
+    // Construct Category Filter Clause
+    let categoryClause: any = {};
+    if (category) {
+      const categoryArray = Array.isArray(category) ? category : [category];
+      categoryClause = { "OR": [{ "category": { "slug_in": categoryArray } }] };
+    }
+
+    // Construct Price Filter Clause
+    let priceClause: any = {};
+    const priceAndClauses: any[] = [];
+    if (price_min !== undefined) {
+      priceAndClauses.push({ "startingPrice_gte": price_min });
+    }
+    if (price_max !== undefined) {
+      priceAndClauses.push({ "startingPrice_lte": price_max });
+    }
+    if (priceAndClauses.length > 0) {
+      priceClause = { "AND": priceAndClauses };
+    }
+
+    // Construct Zone Filter Clause
+    let zoneClause: any = {};
+    if (zones && zones.length > 0) {
+      zoneClause = { "OR": [{ "zone": { "slug_in": zones } }] };
+    }
+
+    // Construct Country Filter Clause
+    let countryClause: any = {};
+    if (country_code) {
+      countryClause = { "OR": [{ "location": { "countryCode": country_code } }] };
+    }
+
+    // Build the main 'AND' array for the 'where' clause
+    const andClauses: any[] = [];
+
+    if (Object.keys(zoneClause).length > 0) {
+      andClauses.push(zoneClause);
+    }
+
+    if (Object.keys(categoryClause).length > 0) {
+      andClauses.push(categoryClause);
+    }
+
+    andClauses.push({}); // Placeholder
+
+    if (Object.keys(priceClause).length > 0) {
+      andClauses.push(priceClause);
+    }
+
+    andClauses.push({}); // Placeholder
+
+    // Add the combined date schedule OR clause
+    if (dateScheduleOrClauses.length > 0) {
+      if (dateScheduleOrClauses.length === 1 && "OR" in dateScheduleOrClauses[0]) {
+        andClauses.push(dateScheduleOrClauses[0]);
+      } else {
+        andClauses.push({ "OR": dateScheduleOrClauses });
+      }
+    }
+
+    if (Object.keys(countryClause).length > 0) {
+      andClauses.push(countryClause);
+    }
+
+    // Construct the final 'where' clause
+    const whereClause: EventFilter = {
+      "visibility_not": "private",
+    };
+
+    if (andClauses.length > 0) {
+      whereClause.AND = andClauses;
+    }
+
+    return {
+      "query": `query getEventListing($lang:String,$limit:Int,$skip:Int,$where:EventFilter,$order:[EventOrder]){
+        eventCollection(locale:$lang,limit:$limit,skip:$skip,where:$where,order:$order){
+          total items{
+            __typename sys{id}id title subtitle slug ticketingUrlSlug 
+            image11{title sys{id publishedAt}url width height contentType}
+            image31{title sys{id publishedAt}url width height contentType}
+            startingPrice currencyCode 
+            schedule{title openTitle openDateTime closeDateTime openScheduleText}
+            isStreamingEvent zoneEntryIncluded streamingUrl buttonLabel cardButtonLabel 
+            eventType buttonLink 
+            zone{id slug title zoneLogo{title sys{id publishedAt}url width height contentType}
+            sponsorLogo{title sys{id publishedAt}url width height contentType}} 
+            location{title address city countryCode seactionHeader location{lat lon}
+            banner{title sys{id publishedAt}url width height contentType} accessibility} 
+            category{id title slug} isComingSoon organizationSlug 
+            carousalCollection(limit:10){
+              items{title sys{id publishedAt}url width height contentType}
+            }
+          }
+        }
+      }`,
+      "variables": {
+        "order": ["sys_publishedAt_DESC"],
+        "lang": "ar-SA",
+        "limit": limit,
+        "skip": skip,
+        "where": whereClause,
+      },
+      "operationName": "getEventListing"
+    };
+  }
+
+  async getEvents(filters: EventFilters = {}): Promise<GraphQLResponse> {
+    try {
+      const payload = this.getEventsPayload(filters);
+      const response: AxiosResponse<GraphQLResponse> = await axios.post(
+        this.url,
+        payload,
+        { headers: this.headers }
+      );
+      return response.data;
+    } catch (error) {
+      console.error('Error fetching events:', error);
+      throw error;
+    }
+  }
+
+  async makeRequest(payload: any): Promise<any> {
+    try {
+      const response = await axios.post(this.url, payload, { headers: this.headers });
+      return response.data;
+    } catch (error) {
+      console.error('Error making request:', error);
+      throw error;
+    }
+  }
+}
+
+// Export a default instance
+export const webookAPI = new WeBookAPI(); 

src/webook/webookBase.ts

@@ -32,7 +32,7 @@ export class WeBookBase {
     if (!this.page) {
       const headless = process.env.PLAYWRIGHT_HEADLESS !== 'false';
       this.browser = await chromium.launchPersistentContext(this.profileDir, {
-        headless: false,
+        headless: headless,
         args: [],
       });
       this.page = this.browser.pages()[0] || await this.browser.newPage();