Fix some Bugs and add some Feathers

d.sh

@@ -1,5 +1,5 @@
 git add .
-git commit -m "all"
+git commit -m "Fix some Bugs and add some Feathers"
 git push
 
 

src/bots/botManager.ts

@@ -72,8 +72,9 @@ export const initializeBot = async (botToken: string, botData?: BotData) => {
     // Set bot ID and load messages
     await messageManager.loadMessages();
     
+  
     // Set language based on bot settings or default to Arabic
-    messageManager.setLanguage(botData?.settings?.language || 'en');
+    messageManager.setLanguage(botData?.settings?.language || 'ar');
     
     // Add bot data to context for use in handlers
     bot.context.botData = botData || null;

src/bots/handlers/index.ts

@@ -34,4 +34,6 @@ export const setupCallbackHandlers = (bot: any) => {
   });
   
  
-}; 
+};
+
+export { setupWeBookFiltersHandlers } from './webookFiltersHandlers'; 

src/bots/handlers/webookFiltersHandlers.ts

@@ -0,0 +1,332 @@
+import { BotContext } from "../types/botTypes";
+import { messageManager } from "../utils/messageManager";
+import { getBackToMainMenuButton } from "../utils/keyboardUtils";
+import { EventFilters } from '../../webook/webookApi';
+import { createLogger } from '../../utils/logger';
+import { callbackReplyHandler } from "../utils/handlerUtils";
+import { Markup } from "telegraf";
+import { getLoggedInMenuKeyboard } from "../utils/keyboardUtils";
+import { webookAPI } from '../../webook/webookApi';
+
+const logger = createLogger('WeBookFiltersHandlers');
+
+// These will be injected or imported from the main handler file
+export let userStates: Map<number, { page: number; filters: EventFilters; totalEvents: number }>;
+export let EVENTS_PER_PAGE: number;
+
+export function injectWeBookFilterDeps(deps: {
+  userStates: typeof userStates,
+  EVENTS_PER_PAGE: number
+}) {
+  userStates = deps.userStates;
+  EVENTS_PER_PAGE = deps.EVENTS_PER_PAGE;
+}
+
+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) {
+    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) {
+    return {
+      message: messageManager.getMessage('error_general'),
+      options: getBackToMainMenuButton()
+    };
+  }
+};
+
+export function getActiveFiltersText(filters: EventFilters): string {
+  const activeFilters = [];
+
+  if (filters.date_filter) {
+    const dateMap: Record<string, string> = {
+      '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(', ') : '';
+}
+
+export function setupWeBookFiltersHandlers(bot: any) {
+  bot.action(/^webook_filter_(.+)$/, handleWeBookFilterAction);
+  bot.action('webook_clear_filters', 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 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: any, index: number) => {
+      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()
+    };
+  }
+}
+
+export 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);
+
+  // Add new button for booking by URL
+  buttons.push([Markup.button.callback('🎟️ Book Tickets by Event URL', 'webook_book_by_url')]);
+
+  // 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);
+} 

src/bots/handlers/webookHandlers.ts

@@ -5,14 +5,16 @@ import { messageManager } from "../utils/messageManager";
 import { webookAPI, EventFilters } from '../../webook/webookApi';
 import { Markup } from "telegraf";
 import { getBackToMainMenuButton, getLoggedInMenuKeyboard } from "../utils/keyboardUtils";
-import { WeBookBooking } from '../../webook/book';
-import { WeBookLogin } from '../../webook/login';
-import { fetchDataFromTable } from '../../db/supabaseHelper';
+import { 
+  injectWeBookFilterDeps, 
+  handleWeBookEventsAction, 
+  handleWeBookPageAction 
+} from './webookFiltersHandlers';
+import { orchestrateBookingProcess, BookingState, isValidWeBookEventUrl, fixWeBookEventUrl, getMaxTicketsAllowed } from '../services/WeBookBookingService';
 
 const logger = createLogger('WeBookHandlers');
 
-// Store user states for pagination and filters
-const userStates = new Map<number, {
+export const userStates = new Map<number, {
   page: number;
   filters: EventFilters;
   totalEvents: number;
@@ -32,159 +34,15 @@ 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));
   bot.action('webook_book_by_url', callbackReplyHandler(handleWeBookBookByUrlAction));
 };
 
-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()
-    };
-  }
-};
+// Inject dependencies for filter handlers
+injectWeBookFilterDeps({
+  userStates,
+  EVENTS_PER_PAGE
+});
 
 export const handleWeBookBackToMenuAction = async (ctx: BotContext) => {
   // Delete the previous message with buttons
@@ -225,164 +83,6 @@ export const handleWeBookBookByUrlAction = async (ctx: BotContext) => {
 };
 
 
-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);
-
-  // Add new button for booking by URL
-  buttons.push([Markup.button.callback('🎟️ Book Tickets by Event URL', 'webook_book_by_url')]);
-
-  // 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(', ') : '';
-}
-
 // Export a handler for booking-by-URL text input
 export async function handleBookByUrlText(ctx: BotContext) {
   const telegramId = ctx.from?.id;
@@ -506,210 +206,27 @@ export async function handleBookByUrlText(ctx: BotContext) {
   return false;
 }
 
-interface WebhookAccount {
-  id: string;
-  email: string;
-  password: string;
-}
+
 
 async function handleBookingProcess(ctx: BotContext, withPayment: boolean) {
   const telegramId = ctx.from?.id;
   if (!telegramId) return;
-
   const state = bookByUrlStates.get(telegramId);
   if (!state || !state.eventUrl || !state.tickets) {
     await ctx.reply(messageManager.getMessage('webook_request_expired'), { parse_mode: 'HTML' });
     return;
   }
-
   state.step = 4;
   bookByUrlStates.set(telegramId, state);
-
-  if (withPayment) {
-    await ctx.reply(messageManager.getMessage('webook_processing_payment'), { parse_mode: 'HTML' });
-  } else {
-    await ctx.reply(messageManager.getMessage('webook_processing_manual'), { parse_mode: 'HTML' });
-  }
-
-  const { eventUrl, tickets: ticketsNeeded } = state;
-  let ticketsObtained = 0;
-  const paymentUrls: string[] = [];
-
-  const { data: accounts, error } = await fetchDataFromTable<WebhookAccount>('account_webhook', 100, 0, { is_active: true });
-
-  if (error || !accounts) {
-    await ctx.reply(messageManager.getMessage('webook_error_fetching_accounts'), { parse_mode: 'HTML' });
-    bookByUrlStates.delete(telegramId);
-    return;
-  }
-
-  const availableAccounts = accounts.filter((a) => a.id && a.email && a.password);
-
-  if (availableAccounts.length === 0) {
-    await ctx.reply(messageManager.getMessage('webook_no_available_accounts'), { parse_mode: 'HTML' });
-    bookByUrlStates.delete(telegramId);
-    return;
-  }
-
-  const paymentType = withPayment ? messageManager.getMessage('webook_automatic_payment') : messageManager.getMessage('webook_manual_payment');
-  
-  // Process accounts in parallel with a limit to avoid overwhelming the system
-  const MAX_CONCURRENT_ACCOUNTS = 3; // Adjust this number based on your system capacity
-  
-  await ctx.reply(
-    messageManager.getMessage('webook_starting_process')
-      .replace('{event_url}', eventUrl)
-      .replace('{fixed_url}', state.fixedUrl || eventUrl)
-      .replace('{tickets_requested}', ticketsNeeded.toString())
-      .replace('{payment_type}', paymentType)
-      .replace('{available_accounts}', availableAccounts.length.toString())
-      .replace('{max_concurrent}', MAX_CONCURRENT_ACCOUNTS.toString()),
-    { parse_mode: 'HTML' }
-  );
-
-  const accountChunks = [];
-  
-  for (let i = 0; i < availableAccounts.length; i += MAX_CONCURRENT_ACCOUNTS) {
-    accountChunks.push(availableAccounts.slice(i, i + MAX_CONCURRENT_ACCOUNTS));
-  }
-
-  for (const accountChunk of accountChunks) {
-    if (ticketsObtained >= ticketsNeeded) {
-      await ctx.reply(messageManager.getMessage('webook_all_tickets_booked'), { parse_mode: 'HTML' });
-      break;
-    }
-
-    // Process this chunk of accounts in parallel
-    const bookingPromises = accountChunk.map(async (account) => {
-      if (ticketsObtained >= ticketsNeeded) {
-        return null; // Skip if we already have enough tickets
-    }
-
-    let login: WeBookLogin | undefined;
-    try {
-        await ctx.reply(messageManager.getMessage('webook_logging_in').replace('{email}', account.email), { parse_mode: 'HTML' });
-      login = new WeBookLogin(account.email, account.password, `${account.id}`);
-      const page = await login.login();
-
-      if (!page || typeof page !== 'object') {
-          await ctx.reply(messageManager.getMessage('webook_login_failed').replace('{email}', account.email), { parse_mode: 'HTML' });
-          return null;
-      }
-        
-        await ctx.reply(messageManager.getMessage('webook_attempting_booking').replace('{email}', account.email), { parse_mode: 'HTML' });
-      const booking = new WeBookBooking(page);
-      const bookingResult = await booking.bookEvent(eventUrl, withPayment);
-
-      if (withPayment) {
-        // Handle number result for automatic payment
-        if (typeof bookingResult === 'number') {
-          const bookedCount = bookingResult;
-          if (bookedCount > 0) {
-            ticketsObtained += bookedCount;
-              await ctx.reply(messageManager.getMessage('webook_booking_success_auto')
-                .replace('{tickets}', bookedCount.toString())
-                .replace('{email}', account.email)
-                .replace('{total_obtained}', ticketsObtained.toString())
-                .replace('{total_needed}', ticketsNeeded.toString()), { parse_mode: 'HTML' });
-              return { success: true, tickets: bookedCount, account: account.email };
-          } else {
-              await ctx.reply(messageManager.getMessage('webook_booking_failed').replace('{email}', account.email), { parse_mode: 'HTML' });
-              return { success: false, account: account.email };
-          }
-        }
-      } else {
-          console.log("bookingResult", bookingResult)
-        // Handle object result for manual payment
-        if (typeof bookingResult === 'object' && bookingResult !== null && 'ticketsCount' in bookingResult) {
-          const result = bookingResult as { ticketsCount: number, paymentUrl?: string };
-          if (result.ticketsCount > 0) {
-            ticketsObtained += result.ticketsCount;
-              if (result.paymentUrl) {
-                paymentUrls.push(result.paymentUrl);
-                
-                // Send payment button immediately after successful booking
-                await ctx.reply(
-                  messageManager.getMessage('webook_booking_success_manual_with_payment')
-                    .replace('{tickets}', result.ticketsCount.toString())
-                    .replace('{email}', account.email)
-                    .replace('{total_obtained}', ticketsObtained.toString())
-                    .replace('{total_needed}', ticketsNeeded.toString()),
-                  {
-                    parse_mode: 'HTML',
-                    ...Markup.inlineKeyboard([
-                      [Markup.button.url('Complete Payment', result.paymentUrl)],
-                      [Markup.button.callback('🔙 Back to Menu', 'webook_back_to_menu')]
-                    ])
-                  }
-                );
-              }
-              await ctx.reply(messageManager.getMessage('webook_booking_success_manual')
-                .replace('{tickets}', result.ticketsCount.toString())
-                .replace('{email}', account.email)
-                .replace('{total_obtained}', ticketsObtained.toString())
-                .replace('{total_needed}', ticketsNeeded.toString()), { parse_mode: 'HTML' });
-              return { success: true, tickets: result.ticketsCount, account: account.email, paymentUrl: result.paymentUrl };
-          } else {
-              await ctx.reply(messageManager.getMessage('webook_booking_failed').replace('{email}', account.email), { parse_mode: 'HTML' });
-              return { success: false, account: account.email };
-            }
-          }
-        }
-        return { success: false, account: account.email };
-    } catch (e: any) {
-        if (e.message && e.message.includes('Tickets sold out')) {
-          await ctx.reply(messageManager.getMessage('webook_tickets_sold_out').replace('{email}', account.email), { parse_mode: 'HTML' });
-        } else {
-      await ctx.reply(messageManager.getMessage('webook_booking_error').replace('{email}', account.email).replace('{error}', e.message), { parse_mode: 'HTML' });
-        }
-        return { success: false, account: account.email, error: e.message };
-    } finally {
-      if (login) {
-        await login.close();
-      }
-    }
-    });
-
-    // Wait for all accounts in this chunk to complete
-    const results = await Promise.all(bookingPromises);
-    
-    // Check if we have enough tickets
-    if (ticketsObtained >= ticketsNeeded) {
-      await ctx.reply(messageManager.getMessage('webook_all_tickets_booked'), { parse_mode: 'HTML' });
-      break;
-    }
-  }
-
-  // Show final results
-  let finalMessage = messageManager.getMessage('webook_booking_completed')
-    .replace('{event_url}', eventUrl)
-    .replace('{fixed_url}', state.fixedUrl || eventUrl)
-    .replace('{tickets_requested}', ticketsNeeded.toString())
-    .replace('{tickets_obtained}', ticketsObtained.toString())
-    .replace('{payment_type}', paymentType)
-    .replace('{accounts_used}', availableAccounts.length.toString())
-    .replace('{max_concurrent}', MAX_CONCURRENT_ACCOUNTS.toString());
-  
-  if (!withPayment && ticketsObtained > 0 && paymentUrls.length > 0) {
-    finalMessage += messageManager.getMessage('webook_payment_buttons_sent');
-    
-        await ctx.reply(
-      finalMessage,
-          {
-            parse_mode: 'HTML',
-            ...Markup.inlineKeyboard([
-              [Markup.button.callback('🔙 Back to Menu', 'webook_back_to_menu')]
-            ])
-          }
-        );
-  } else if (!withPayment && ticketsObtained > 0) {
-    finalMessage += messageManager.getMessage('webook_manual_payment_required');
-    await ctx.reply(finalMessage, { parse_mode: 'HTML' });
-      } else {
-    await ctx.reply(finalMessage, { parse_mode: 'HTML' });
-  }
-
-  bookByUrlStates.delete(telegramId);
+  // Ensure state matches BookingState type
+  const bookingState: BookingState = {
+    eventUrl: state.eventUrl,
+    fixedUrl: state.fixedUrl,
+    tickets: state.tickets,
+    step: state.step,
+    lastBotMessageId: state.lastBotMessageId
+  };
+  await orchestrateBookingProcess(ctx, bookingState, withPayment, bookByUrlStates as Map<number, BookingState>);
 }
 
 // Handle Yes/No payment buttons
@@ -733,55 +250,4 @@ export function setupWeBookBookByUrlPaymentHandlers(bot: any) {
     }
     await handleBookingProcess(ctx, false);
   });
-}
-
-// Helper: Validate WeBook event URL
-function isValidWeBookEventUrl(url: string): boolean {
-  try {
-    const u = new URL(url);
-    return u.hostname === 'webook.com' && /\/events\//.test(u.pathname);
-  } catch {
-    return false;
-  }
-}
-
-// Helper: Fix WeBook event URL
-function fixWeBookEventUrl(url: string): string {
-  let fixed = url.replace('/ar/', '/en/');
-  if (!/\/en\//.test(fixed)) fixed = fixed.replace('/events/', '/en/events/');
-  if (!/\/book$/.test(fixed)) fixed = fixed.replace(/\/?$/, '/book');
-  return fixed;
-}
-
-// Real implementation: get max tickets allowed (clickCount) using Playwright
-async function getMaxTicketsAllowed(eventUrl: string): Promise<number> {
- 
-  const email = process.env.WEBOOK_EMAIL || 'mfoud444@gmail.com';
-  const password = process.env.WEBOOK_PASSWORD || '009988Ppooii@@@@';
-  try {
-    return 5;
-  //   // Login and get a Playwright page
-  //   const login = new WeBookLogin(email, password);
-  //   const page = await login.login();
-  //   if (!page) throw new Error('Login failed');
-  //   // Use WeBookBooking to navigate and count max tickets
-  //   const booking = new WeBookBooking(page);
-  //    await page.goto(eventUrl);
-    
-  //   // Check if tickets are available first
-  //   if (!(await booking.areTicketsAvailable())) {
-  //     console.warn('No tickets available for this event');
-  //     if (page.context()) await page.context().close();
-  //     return 0;
-  //   }
-    
-  //   // Use the selectMaxTickets method and return the clickCount
-  //   const clickCount = await booking.selectMaxTickets();
-  //   if (page.context()) await page.context().close();
-  //   return clickCount;
-  } catch (e) {
-    console.error('Error in getMaxTicketsAllowed:', e);
-    return 5; // fallback
-
-  }
 }

src/bots/services/WeBookBookingService.ts

@@ -0,0 +1,329 @@
+import { BotContext } from "../types/botTypes";
+import { messageManager } from "../utils/messageManager";
+import { WeBookBooking } from '../../webook/book';
+import { WeBookLogin } from '../../webook/login';
+import { fetchDataFromTable } from '../../db/supabaseHelper';
+import { Markup } from "telegraf";
+
+export interface WebhookAccount {
+  id: string;
+  email: string;
+  password: string;
+}
+
+export interface BookingState {
+  eventUrl: string;
+  fixedUrl?: string;
+  tickets: number;
+  step: number;
+  lastBotMessageId?: number;
+}
+
+export interface BookingResult {
+  success: boolean;
+  tickets?: number;
+  account: string;
+  paymentUrl?: string;
+  error?: string;
+}
+
+export function chunkAccounts<T>(accounts: T[], chunkSize: number): T[][] {
+  const chunks: T[][] = [];
+  for (let i = 0; i < accounts.length; i += chunkSize) {
+    chunks.push(accounts.slice(i, i + chunkSize));
+  }
+  return chunks;
+}
+
+export async function bookTicketsForAccount(
+  ctx: BotContext,
+  account: WebhookAccount,
+  eventUrl: string,
+  withPayment: boolean,
+  ticketsObtained: number,
+  ticketsNeeded: number,
+  isLogin: boolean = false
+): Promise<BookingResult> {
+  let login: WeBookLogin | undefined;
+  try {
+    if (isLogin) {
+      await ctx.reply(messageManager.getMessage('webook_logging_in').replace('{email}', account.email), { parse_mode: 'HTML' });
+      login = new WeBookLogin(account.email, account.password, `${account.id}`);
+      const page = await login.login();
+      if (!page || typeof page !== 'object') {
+        await ctx.reply(messageManager.getMessage('webook_login_failed').replace('{email}', account.email), { parse_mode: 'HTML' });
+        return { success: false, account: account.email };
+      }
+      await ctx.reply(messageManager.getMessage('webook_attempting_booking').replace('{email}', account.email), { parse_mode: 'HTML' });
+      const booking = new WeBookBooking(page);
+      const bookingResult = await booking.bookEvent(eventUrl, withPayment);
+      if (withPayment) {
+        if (typeof bookingResult === 'number') {
+          const bookedCount = bookingResult;
+          if (bookedCount > 0) {
+            await ctx.reply(messageManager.getMessage('webook_booking_success_auto')
+              .replace('{tickets}', bookedCount.toString())
+              .replace('{email}', account.email)
+              .replace('{total_obtained}', (ticketsObtained + bookedCount).toString())
+              .replace('{total_needed}', ticketsNeeded.toString()), { parse_mode: 'HTML' });
+            return { success: true, tickets: bookedCount, account: account.email };
+          } else {
+            await ctx.reply(messageManager.getMessage('webook_booking_failed').replace('{email}', account.email), { parse_mode: 'HTML' });
+            return { success: false, account: account.email };
+          }
+        }
+      } else {
+        if (typeof bookingResult === 'object' && bookingResult !== null && 'ticketsCount' in bookingResult) {
+          const result = bookingResult as { ticketsCount: number, paymentUrl?: string };
+          if (result.ticketsCount > 0) {
+            if (result.paymentUrl) {
+              await ctx.reply(
+                messageManager.getMessage('webook_booking_success_manual_with_payment')
+                  .replace('{tickets}', result.ticketsCount.toString())
+                  .replace('{email}', account.email)
+                  .replace('{total_obtained}', (ticketsObtained + result.ticketsCount).toString())
+                  .replace('{total_needed}', ticketsNeeded.toString()),
+                {
+                  parse_mode: 'HTML',
+                  ...Markup.inlineKeyboard([
+                    [Markup.button.url('Complete Payment', result.paymentUrl)],
+                    [Markup.button.callback('🔙 Back to Menu', 'webook_back_to_menu')]
+                  ])
+                }
+              );
+            }
+            await ctx.reply(messageManager.getMessage('webook_booking_success_manual')
+              .replace('{tickets}', result.ticketsCount.toString())
+              .replace('{email}', account.email)
+              .replace('{total_obtained}', (ticketsObtained + result.ticketsCount).toString())
+              .replace('{total_needed}', ticketsNeeded.toString()), { parse_mode: 'HTML' });
+            return { success: true, tickets: result.ticketsCount, account: account.email, paymentUrl: result.paymentUrl };
+          } else {
+            await ctx.reply(messageManager.getMessage('webook_booking_failed').replace('{email}', account.email), { parse_mode: 'HTML' });
+            return { success: false, account: account.email };
+          }
+        }
+      }
+      return { success: false, account: account.email };
+    } else {
+      // No login, use direct booking
+      await ctx.reply(messageManager.getMessage('webook_attempting_booking').replace('{email}', account.email), { parse_mode: 'HTML' });
+      const bookingResult = await WeBookBooking.bookDirect(eventUrl, `${account.id}`, withPayment);
+      if (withPayment) {
+        if (typeof bookingResult === 'number') {
+          const bookedCount = bookingResult;
+          if (bookedCount > 0) {
+            await ctx.reply(messageManager.getMessage('webook_booking_success_auto')
+              .replace('{tickets}', bookedCount.toString())
+              .replace('{email}', account.email)
+              .replace('{total_obtained}', (ticketsObtained + bookedCount).toString())
+              .replace('{total_needed}', ticketsNeeded.toString()), { parse_mode: 'HTML' });
+            return { success: true, tickets: bookedCount, account: account.email };
+          } else {
+            await ctx.reply(messageManager.getMessage('webook_booking_failed').replace('{email}', account.email), { parse_mode: 'HTML' });
+            return { success: false, account: account.email };
+          }
+        }
+      } else {
+        if (typeof bookingResult === 'object' && bookingResult !== null && 'ticketsCount' in bookingResult) {
+          const result = bookingResult as { ticketsCount: number, paymentUrl?: string };
+          if (result.ticketsCount > 0) {
+            if (result.paymentUrl) {
+              await ctx.reply(
+                messageManager.getMessage('webook_booking_success_manual_with_payment')
+                  .replace('{tickets}', result.ticketsCount.toString())
+                  .replace('{email}', account.email)
+                  .replace('{total_obtained}', (ticketsObtained + result.ticketsCount).toString())
+                  .replace('{total_needed}', ticketsNeeded.toString()),
+                {
+                  parse_mode: 'HTML',
+                  ...Markup.inlineKeyboard([
+                    [Markup.button.url('Complete Payment', result.paymentUrl)],
+                    [Markup.button.callback('🔙 Back to Menu', 'webook_back_to_menu')]
+                  ])
+                }
+              );
+            }
+            await ctx.reply(messageManager.getMessage('webook_booking_success_manual')
+              .replace('{tickets}', result.ticketsCount.toString())
+              .replace('{email}', account.email)
+              .replace('{total_obtained}', (ticketsObtained + result.ticketsCount).toString())
+              .replace('{total_needed}', ticketsNeeded.toString()), { parse_mode: 'HTML' });
+            return { success: true, tickets: result.ticketsCount, account: account.email, paymentUrl: result.paymentUrl };
+          } else {
+            await ctx.reply(messageManager.getMessage('webook_booking_failed').replace('{email}', account.email), { parse_mode: 'HTML' });
+            return { success: false, account: account.email };
+          }
+        }
+      }
+      return { success: false, account: account.email };
+    }
+  } catch (e: any) {
+    if (e.message && e.message.includes('Tickets sold out')) {
+      await ctx.reply(messageManager.getMessage('webook_tickets_sold_out').replace('{email}', account.email), { parse_mode: 'HTML' });
+    } else {
+      await ctx.reply(messageManager.getMessage('webook_booking_error').replace('{email}', account.email).replace('{error}', e.message), { parse_mode: 'HTML' });
+    }
+    return { success: false, account: account.email, error: e.message };
+  } finally {
+    if (login) {
+      await login.close();
+    }
+  }
+}
+
+export async function sendBookingSummary(
+  ctx: BotContext,
+  state: BookingState,
+  paymentType: string,
+  availableAccounts: number,
+  maxConcurrent: number
+) {
+  await ctx.reply(
+    messageManager.getMessage('webook_starting_process')
+      .replace('{event_url}', state.eventUrl)
+      .replace('{fixed_url}', state.fixedUrl || state.eventUrl)
+      .replace('{tickets_requested}', state.tickets.toString())
+      .replace('{payment_type}', paymentType)
+      .replace('{available_accounts}', availableAccounts.toString())
+      .replace('{max_concurrent}', maxConcurrent.toString()),
+    { parse_mode: 'HTML' }
+  );
+}
+
+export async function orchestrateBookingProcess(
+  ctx: BotContext,
+  state: BookingState,
+  withPayment: boolean,
+  bookByUrlStates: Map<number, BookingState>
+) {
+  const telegramId = ctx.from?.id;
+  if (!telegramId) return;
+  let ticketsObtained = 0;
+  const paymentUrls: string[] = [];
+  const { eventUrl, tickets: ticketsNeeded } = state;
+  const { data: accounts, error } = await fetchDataFromTable<WebhookAccount>('account_webhook', 100, 0, { is_active: true });
+  if (error || !accounts) {
+    await ctx.reply(messageManager.getMessage('webook_error_fetching_accounts'), { parse_mode: 'HTML' });
+    bookByUrlStates.delete(telegramId);
+    return;
+  }
+  const availableAccounts = accounts.filter((a) => a.id && a.email && a.password);
+  if (availableAccounts.length === 0) {
+    await ctx.reply(messageManager.getMessage('webook_no_available_accounts'), { parse_mode: 'HTML' });
+    bookByUrlStates.delete(telegramId);
+    return;
+  }
+  const paymentType = withPayment ? messageManager.getMessage('webook_automatic_payment') : messageManager.getMessage('webook_manual_payment');
+  const MAX_CONCURRENT_ACCOUNTS = 3;
+  await sendBookingSummary(ctx, state, paymentType, availableAccounts.length, MAX_CONCURRENT_ACCOUNTS);
+  const accountChunks = chunkAccounts(availableAccounts, MAX_CONCURRENT_ACCOUNTS);
+  for (const accountChunk of accountChunks) {
+    if (ticketsObtained >= ticketsNeeded) {
+      await ctx.reply(messageManager.getMessage('webook_all_tickets_booked'), { parse_mode: 'HTML' });
+      break;
+    }
+    const bookingResults = await Promise.all(
+      accountChunk.map(account =>
+        ticketsObtained >= ticketsNeeded
+          ? Promise.resolve(null)
+          : bookTicketsForAccount(ctx, account, eventUrl, withPayment, ticketsObtained, ticketsNeeded)
+      )
+    );
+    for (const result of bookingResults) {
+      if (result && result.success && result.tickets) {
+        ticketsObtained += result.tickets;
+        if (!withPayment && result.paymentUrl) {
+          paymentUrls.push(result.paymentUrl);
+        }
+      }
+    }
+    if (ticketsObtained >= ticketsNeeded) {
+      await ctx.reply(messageManager.getMessage('webook_all_tickets_booked'), { parse_mode: 'HTML' });
+      break;
+    }
+  }
+  let finalMessage = messageManager.getMessage('webook_booking_completed')
+    .replace('{event_url}', eventUrl)
+    .replace('{fixed_url}', state.fixedUrl || eventUrl)
+    .replace('{tickets_requested}', ticketsNeeded.toString())
+    .replace('{tickets_obtained}', ticketsObtained.toString())
+    .replace('{payment_type}', paymentType)
+    .replace('{accounts_used}', availableAccounts.length.toString())
+    .replace('{max_concurrent}', MAX_CONCURRENT_ACCOUNTS.toString());
+  if (!withPayment && ticketsObtained > 0 && paymentUrls.length > 0) {
+    finalMessage += messageManager.getMessage('webook_payment_buttons_sent');
+    await ctx.reply(
+      finalMessage,
+      {
+        parse_mode: 'HTML',
+        ...Markup.inlineKeyboard([
+          [Markup.button.callback('🔙 Back to Menu', 'webook_back_to_menu')]
+        ])
+      }
+    );
+  } else if (!withPayment && ticketsObtained > 0) {
+    finalMessage += messageManager.getMessage('webook_manual_payment_required');
+    await ctx.reply(finalMessage, { parse_mode: 'HTML' });
+  } else {
+    await ctx.reply(finalMessage, { parse_mode: 'HTML' });
+  }
+  bookByUrlStates.delete(telegramId);
+}
+
+export function isValidWeBookEventUrl(url: string): boolean {
+  try {
+    const u = new URL(url);
+    return u.hostname === 'webook.com' && /\/events\//.test(u.pathname);
+  } catch {
+    return false;
+  }
+}
+
+
+export function fixWeBookEventUrl(url: string): string {
+  try {
+    const u = new URL(url);
+    // Replace any language code in the path before /events/ with /en/
+    u.pathname = u.pathname.replace(/^\/(?:[a-zA-Z-]+)\/(events\/)/, '/en/$1');
+    // If /en/ is not present before /events/, insert it
+    if (!/\/en\/events\//.test(u.pathname)) {
+      u.pathname = u.pathname.replace(/\/events\//, '/en/events/');
+    }
+    // Ensure the path ends with /book
+    if (!/\/book$/.test(u.pathname)) {
+      u.pathname = u.pathname.replace(/\/?$/, '/book');
+    }
+    return u.toString();
+  } catch {
+    // fallback to previous logic if URL parsing fails
+    let fixed = url.replace(/\/[a-zA-Z-]+\/(events\/)/, '/en/$1');
+    if (!/\/en\//.test(fixed)) fixed = fixed.replace('/events/', '/en/events/');
+    if (!/\/book$/.test(fixed)) fixed = fixed.replace(/\/?$/, '/book');
+    return fixed;
+  }
+}
+
+export async function getMaxTicketsAllowed(eventUrl: string): Promise<number> {
+  const email = process.env.WEBOOK_EMAIL || 'mfoud444@gmail.com';
+  const password = process.env.WEBOOK_PASSWORD || '009988Ppooii@@@@';
+  try {
+    return 5;
+    // Real implementation commented out for now
+    // const login = new WeBookLogin(email, password);
+    // const page = await login.login();
+    // if (!page) throw new Error('Login failed');
+    // const booking = new WeBookBooking(page);
+    // await page.goto(eventUrl);
+    // if (!(await booking.areTicketsAvailable())) {
+    //   if (page.context()) await page.context().close();
+    //   return 0;
+    // }
+    // const clickCount = await booking.selectMaxTickets();
+    // if (page.context()) await page.context().close();
+    // return clickCount;
+  } catch (e) {
+    console.error('Error in getMaxTicketsAllowed:', e);
+    return 5;
+  }
+} 

src/bots/utils/keyboardUtils.ts

@@ -13,9 +13,9 @@ export const getMainMenuKeyboard = () => {
   return Markup.inlineKeyboard([
     // [Markup.button.callback(messageManager.getMessage('btn_login'), 'login')],
     // [Markup.button.callback(messageManager.getMessage('btn_terms'), 'terms')],
-    [Markup.button.callback(messageManager.getMessage('btn_webook_events'), 'webook_events'),
-      // Markup.button.callback('🎟️ Book Tickets by Event URL', 'webook_book_by_url')
-    ],
+    // [Markup.button.callback(messageManager.getMessage('btn_webook_events'), 'webook_events'),
+    //   // Markup.button.callback('🎟️ Book Tickets by Event URL', 'webook_book_by_url')
+    // ],
     [Markup.button.callback(messageManager.getMessage('btn_webook_book_by_url'), 'webook_book_by_url')],
     // [Markup.button.callback(messageManager.getMessage('btn_new_members'), 'new_members')],
     // [Markup.button.callback(messageManager.getMessage('btn_stats'), 'stats')],

src/index.ts

@@ -39,4 +39,5 @@ startServer();
 // webookMain().catch(e => { console.error('WeBook Fatal error:', e); });
 
 
-// handleAddTelegrafBot("1e186256-fdd6-453f-8344-fd824660b8bd")
+
+handleAddTelegrafBot("1e186256-fdd6-453f-8344-fd824660b8bd")

src/webook/book.ts

@@ -3,10 +3,32 @@ import { WeBookBase } from './webookBase';
 import { fetchAllPaymentMethods } from '../db/supabaseHelper';
 
 export class WeBookBooking extends WeBookBase {
-  constructor(page: Page, profileDir?: string) {
-    super(profileDir, page);
-    if (!this.page) {
-      throw new Error('A Playwright page object must be provided to WeBookBooking');
+  constructor(pageOrProfileDir?: Page | string, profileDirIfPage?: string) {
+    if (pageOrProfileDir && typeof pageOrProfileDir === 'object') {
+      // page provided
+      super(profileDirIfPage, pageOrProfileDir as Page);
+      if (!this.page) {
+        throw new Error('A Playwright page object must be provided to WeBookBooking');
+      }
+    } else {
+      // only profileDir provided (or nothing)
+      super(pageOrProfileDir as string | undefined);
+    }
+  }
+
+  /**
+   * Static helper to book directly with just eventUrl and profileDir (no login)
+   * @param eventUrl string
+   * @param profileDir string (optional)
+   * @param withPayment boolean (default true)
+   */
+  static async bookDirect(eventUrl: string, profileDir?: string, withPayment: boolean = true): Promise<number | { ticketsCount: number, paymentUrl?: string }> {
+    const booking = new WeBookBooking(profileDir);
+    await booking.setupBrowser();
+    try {
+      return await booking.bookEvent(eventUrl, withPayment);
+    } finally {
+      await booking.close();
     }
   }
 

src/webook/login.ts

@@ -64,10 +64,11 @@ export class WeBookLogin extends WeBookBase {
     if (!this.page) throw new Error('Page not initialized');
     try {
     
-      //  this.page.goto('https://webook.com/en');
-      await this.page.goto('https://webook.com/en', { waitUntil: 'networkidle' });
+      await this.page.goto('https://webook.com/en');
+      // await this.page.goto('https://webook.com/en', { waitUntil: 'networkidle' });
       await this.handleCookies();
      
+      
       await this.page.screenshot({ path: 'logs/login-check-failed.png', fullPage: true });