all

corrected_sql_statements.sql

@@ -0,0 +1,245 @@
+-- WeBook Event URL Input
+INSERT INTO bot_messages (key, ar_value, en_value, description) VALUES 
+('webook_enter_event_url', 
+ '🔗 يرجى إرسال رابط الحدث الذي تريد حجز التذاكر له (مثال: https://webook.com/en/events/mdlbeast-beast-house-ec/book)', 
+ '🔗 Please send the event URL you want to book tickets for (e.g. https://webook.com/en/events/mdlbeast-beast-house-ec/book)', 
+ 'Message asking user to enter WeBook event URL');
+
+-- Invalid URL
+INSERT INTO bot_messages (key, ar_value, en_value, description) VALUES 
+('webook_invalid_url', 
+ '❌ رابط الحدث غير صحيح. يرجى إرسال رابط صحيح لحدث WeBook.', 
+ '❌ Invalid event URL. Please send a valid WeBook event URL.', 
+ 'Error message for invalid WeBook event URL');
+
+-- URL Accepted
+INSERT INTO bot_messages (key, ar_value, en_value, description) VALUES 
+('webook_url_accepted', 
+ '✅ تم قبول الرابط!
+
+📍 الرابط الأصلي: {original_url}
+🔗 الرابط المصحح: {fixed_url}
+
+كم عدد التذاكر التي تريد حجزها؟ (يرجى إدخال رقم)', 
+ '✅ URL accepted!
+
+📍 Original URL: {original_url}
+🔗 Fixed URL: {fixed_url}
+
+How many tickets do you want to book? (Please enter a number)', 
+ 'Message confirming URL acceptance and asking for ticket count');
+
+-- Invalid Ticket Count
+INSERT INTO bot_messages (key, ar_value, en_value, description) VALUES 
+('webook_invalid_ticket_count', 
+ '❌ يرجى إدخال عدد صحيح من التذاكر.', 
+ '❌ Please enter a valid number of tickets.', 
+ 'Error message for invalid ticket count');
+
+-- No Tickets Available
+INSERT INTO bot_messages (key, ar_value, en_value, description) VALUES 
+('webook_no_tickets_available', 
+ '❌ لا توجد تذاكر متاحة حالياً لهذا الحدث:
+
+📍 رابط الحدث: {event_url}
+🎫 التذاكر المطلوبة: {tickets_requested}
+
+يرجى المحاولة مرة أخرى لاحقاً.', 
+ '❌ No tickets are currently available for this event:
+
+📍 Event URL: {event_url}
+🎫 Tickets Requested: {tickets_requested}
+
+Please try again later.', 
+ 'Message when no tickets are available for the event');
+
+-- Booking Summary
+INSERT INTO bot_messages (key, ar_value, en_value, description) VALUES 
+('webook_booking_summary', 
+ '📋 ملخص الحجز:
+
+📍 رابط الحدث: {event_url}
+🎫 التذاكر المطلوبة: {tickets_requested}
+📊 الحد الأقصى للتذاكر لكل حساب: {max_tickets_per_account}
+
+', 
+ '📋 Booking Summary:
+
+📍 Event URL: {event_url}
+🎫 Tickets Requested: {tickets_requested}
+📊 Max Tickets Per Account: {max_tickets_per_account}
+
+', 
+ 'Booking summary message before payment question');
+
+-- Payment Question
+INSERT INTO bot_messages (key, ar_value, en_value, description) VALUES 
+('webook_payment_question', 
+ 'هل تريد إجراء الدفع تلقائياً؟', 
+ 'Do you want to make payment automatically?', 
+ 'Question asking if user wants automatic payment');
+
+-- Request Expired
+INSERT INTO bot_messages (key, ar_value, en_value, description) VALUES 
+('webook_request_expired', 
+ 'انتهت صلاحية طلبك أو أنه غير صحيح. يرجى البدء من جديد.', 
+ 'Your request expired or is invalid. Please start again.', 
+ 'Message when booking request has expired');
+
+-- Processing Messages
+INSERT INTO bot_messages (key, ar_value, en_value, description) VALUES 
+('webook_processing_payment', 
+ '💳 يرجى الانتظار بينما نعالج حجزك والدفع...', 
+ '💳 Please wait while we process your booking and payment...', 
+ 'Message when processing booking with automatic payment'),
+('webook_processing_manual', 
+ '📝 حجز تذاكرك بدون دفع تلقائي...', 
+ '📝 Booking your tickets without automatic payment...', 
+ 'Message when processing booking without automatic payment');
+
+-- Account Related Messages
+INSERT INTO bot_messages (key, ar_value, en_value, description) VALUES 
+('webook_error_fetching_accounts', 
+ 'خطأ في جلب الحسابات للحجز.', 
+ 'Error fetching accounts for booking.', 
+ 'Error message when failing to fetch accounts'),
+('webook_no_available_accounts', 
+ 'لا توجد حسابات نشطة متاحة مع بيانات الاعتماد للحجز.', 
+ 'No active accounts with credentials available for booking.', 
+ 'Message when no accounts are available for booking');
+
+-- Payment Types
+INSERT INTO bot_messages (key, ar_value, en_value, description) VALUES 
+('webook_automatic_payment', 
+ '💳 الدفع التلقائي', 
+ '💳 Automatic Payment', 
+ 'Label for automatic payment type'),
+('webook_manual_payment', 
+ '📝 الدفع اليدوي', 
+ '📝 Manual Payment', 
+ 'Label for manual payment type');
+
+-- Starting Process
+INSERT INTO bot_messages (key, ar_value, en_value, description) VALUES 
+('webook_starting_process', 
+ '🚀 بدء عملية الحجز:
+
+📍 راب�� الحدث: {event_url}
+🔗 الرابط المصحح: {fixed_url}
+🎫 التذاكر المطلوبة: {tickets_requested}
+💳 نوع الدفع: {payment_type}
+👥 الحسابات المتاحة: {available_accounts}
+⚡ وضع المعالجة: متوازي ({max_concurrent} حسابات في وقت واحد)
+
+معالجة الحسابات بالتوازي للحجز الأسرع...', 
+ '🚀 Starting booking process:
+
+📍 Event URL: {event_url}
+🔗 Fixed URL: {fixed_url}
+🎫 Tickets Requested: {tickets_requested}
+💳 Payment Type: {payment_type}
+👥 Available Accounts: {available_accounts}
+⚡ Processing Mode: Parallel ({max_concurrent} accounts at once)
+
+Processing accounts in parallel for faster booking...', 
+ 'Message when starting the booking process');
+
+-- Booking Status Messages
+INSERT INTO bot_messages (key, ar_value, en_value, description) VALUES 
+('webook_all_tickets_booked', 
+ 'تم حجز جميع التذاكر المطلوبة.', 
+ 'All required tickets have been booked.', 
+ 'Message when all required tickets are booked'),
+('webook_logging_in', 
+ '🔐 تسجيل الدخول بالحساب: {email}', 
+ '🔐 Logging in with account: {email}', 
+ 'Message when logging in with an account'),
+('webook_login_failed', 
+ '❌ فشل تسجيل الدخول بالحساب: {email}. جاري تجربة الحساب التالي...', 
+ '❌ Login failed for account: {email}. Trying next account...', 
+ 'Message when login fails for an account'),
+('webook_attempting_booking', 
+ '🎯 محاولة حجز التذاكر مع: {email}', 
+ '🎯 Attempting to book tickets with: {email}', 
+ 'Message when attempting to book with an account');
+
+-- Booking Success Messages
+INSERT INTO bot_messages (key, ar_value, en_value, description) VALUES 
+('webook_booking_success_auto', 
+ '✅ تم حجز {tickets} تذاكر بنجاح مع {email} (الدفع التلقائي)
+📊 إجمالي التذاكر المحجوزة: {total_obtained}/{total_needed}', 
+ '✅ Successfully booked {tickets} tickets with {email} (Auto Payment)
+📊 Total tickets obtained: {total_obtained}/{total_needed}', 
+ 'Message when automatic booking is successful'),
+('webook_booking_success_manual', 
+ '✅ تم حجز {tickets} تذاكر بنجاح مع {email} (الدفع اليدوي)
+📊 إجمالي التذاكر المحجوزة: {total_obtained}/{total_needed}', 
+ '✅ Successfully booked {tickets} tickets with {email} (Manual Payment)
+📊 Total tickets obtained: {total_obtained}/{total_needed}', 
+ 'Message when manual booking is successful'),
+('webook_booking_success_manual_with_payment', 
+ '🎟️ تم حجز {tickets} تذاكر بنجاح مع {email} (الدفع اليدوي)!
+
+📊 إجمالي التذاكر المحجوزة: {total_obtained}/{total_needed}
+
+لإكمال هذا الحجز، يرجى إنهاء الدفع:', 
+ '🎟️ Successfully booked {tickets} tickets with {email} (Manual Payment)!
+
+📊 Total tickets obtained: {total_obtained}/{total_needed}
+
+To complete this booking, please finish the payment:', 
+ 'Message when manual booking is successful with payment URL');
+
+-- Booking Failure Messages
+INSERT INTO bot_messages (key, ar_value, en_value, description) VALUES 
+('webook_booking_failed', 
+ '❌ لا توجد تذاكر متاحة أو فشل الحجز مع الحساب: {email}. جاري تجربة الحساب التالي...', 
+ '❌ No tickets available or booking failed with account: {email}. Trying next account...', 
+ 'Message when booking fails with an account'),
+('webook_tickets_sold_out', 
+ '❌ نفدت التذاكر للحساب {email}. جاري تجربة الحساب التالي...', 
+ '❌ Tickets sold out for account {email}. Trying next account...', 
+ 'Message when tickets are sold out for an account'),
+('webook_booking_error', 
+ 'حدث خطأ أثناء الحجز مع {email}: {error}', 
+ 'An error occurred while booking with {email}: {error}', 
+ 'Message when an error occurs during booking');
+
+-- Final Results Messages
+INSERT INTO bot_messages (key, ar_value, en_value, description) VALUES 
+('webook_booking_completed', 
+ '🏁 اكتملت عملية الحجز!
+
+📍 رابط الحدث: {event_url}
+🔗 الرابط المصحح: {fixed_url}
+🎫 التذاكر المطلوبة: {tickets_requested}
+✅ التذاكر المحجوزة: {tickets_obtained}
+💳 نوع الدفع: {payment_type}
+👥 الحسابات المستخدمة: {accounts_used}
+⚡ وضع المعالجة: متوازي ({max_concurrent} حسابات في وقت واحد)', 
+ '🏁 Booking process completed!
+
+📍 Event URL: {event_url}
+🔗 Fixed URL: {fixed_url}
+🎫 Tickets Requested: {tickets_requested}
+✅ Tickets Obtained: {tickets_obtained}
+💳 Payment Type: {payment_type}
+👥 Accounts Used: {accounts_used}
+⚡ Processing Mode: Parallel ({max_concurrent} accounts at once)', 
+ 'Final booking completion message'),
+('webook_payment_buttons_sent', 
+ '
+
+💳 تم إرسال أزرار الدفع لكل حجز ��اجح أعلاه.', 
+ '
+
+💳 Payment buttons have been sent for each successful booking above.', 
+ 'Message about payment buttons being sent'),
+('webook_manual_payment_required', 
+ '
+
+⚠️ ستحتاج إلى إكمال الدفع يدوياً.', 
+ '
+
+⚠️ You will need to complete payment manually.', 
+ 'Message about manual payment requirement'); 

src/bots/botManager.ts

@@ -15,10 +15,10 @@ const logger = createLogger('BotManager');
 
 export const BotCommands: { command: string; description: string }[] = [
   { command: 'start', description: 'بدء البوت' },
-  { command: 'help', description: 'يعرض قائمة المساعدة' },
-  { command: 'about', description: 'معلومات عن البوت' },
-  { command: 'contact', description: 'تواصل معنا' },
-  { command: 'balance', description: 'رصيدي' },
+  // { command: 'help', description: 'يعرض قائمة المساعدة' },
+  // { command: 'about', description: 'معلومات عن البوت' },
+  // { command: 'contact', description: 'تواصل معنا' },
+  // { command: 'balance', description: 'رصيدي' },
   { command: 'change_language', description: 'تغيير اللغة / Change language' },
 ];
 

src/bots/handlers/webookHandlers.ts

@@ -19,7 +19,13 @@ const userStates = new Map<number, {
 }>();
 
 // Add user state for booking by URL
-const bookByUrlStates = new Map<number, { step: number, eventUrl?: string, fixedUrl?: string, tickets?: number }>();
+const bookByUrlStates = new Map<number, { 
+  step: number, 
+  eventUrl?: string, 
+  fixedUrl?: string, 
+  tickets?: number,
+  lastBotMessageId?: number 
+}>();
 
 const EVENTS_PER_PAGE = 5;
 
@@ -181,6 +187,13 @@ export const handleWeBookClearFiltersAction = async (ctx: BotContext) => {
 };
 
 export const handleWeBookBackToMenuAction = async (ctx: BotContext) => {
+  // Delete the previous message with buttons
+  try {
+    await ctx.deleteMessage();
+  } catch (e) {
+    console.log('Could not delete previous message:', e);
+  }
+  
   return {
     message: messageManager.getMessage('main_menu_welcome_back').replace('{name}', ctx.from?.first_name || 'User'),
     options: getLoggedInMenuKeyboard()
@@ -189,13 +202,26 @@ export const handleWeBookBackToMenuAction = async (ctx: BotContext) => {
 
 export const handleWeBookBookByUrlAction = async (ctx: BotContext) => {
   const telegramId = ctx.from?.id;
-  if (!telegramId) return { message: 'User not found.', options: getBackToMainMenuButton() };
+  if (!telegramId) return { message: messageManager.getMessage('error_user_not_found'), options: getBackToMainMenuButton() };
+  
+  // Initialize state and send message directly
   bookByUrlStates.set(telegramId, { step: 1 });
   console.log('[BookByUrl] Set state for', telegramId, { step: 1 });
-  return {
-    message: '🔗 Please send the event URL you want to book tickets for (e.g. https://webook.com/en/events/mdlbeast-beast-house-ec/book)',
-    options: { parse_mode: 'HTML', ...getBackToMainMenuButton() }
-  };
+  
+  const reply = await ctx.reply(
+    messageManager.getMessage('webook_enter_event_url'),
+    { parse_mode: 'HTML', ...getBackToMainMenuButton() }
+  );
+  
+  // Store the message ID for later deletion
+  const state = bookByUrlStates.get(telegramId);
+  if (state) {
+    state.lastBotMessageId = reply.message_id;
+    bookByUrlStates.set(telegramId, state);
+  }
+  
+  // Return null to prevent callbackReplyHandler from sending another message
+  return null;
 };
 
 
@@ -366,11 +392,33 @@ export async function handleBookByUrlText(ctx: BotContext) {
   if (!state) return false;
   const message = ctx.message;
   if (!message || typeof message !== 'object' || !('text' in message) || typeof message.text !== 'string') return false;
+  
+  // Delete the user's message to clean up the chat
+  try {
+    await ctx.deleteMessage();
+  } catch (e) {
+    console.log('Could not delete user message:', e);
+  }
+  
   if (state.step === 1) {
+    // Delete the bot's previous message asking for URL
+    if (state.lastBotMessageId) {
+      try {
+        await ctx.deleteMessage(state.lastBotMessageId);
+      } catch (e) {
+        console.log('Could not delete bot message:', e);
+      }
+    }
+    
     // Validate and fix URL
     const url = message.text.trim();
     if (!isValidWeBookEventUrl(url)) {
-      await ctx.reply('❌ Invalid event URL. Please send a valid WeBook event URL.', getBackToMainMenuButton());
+      const reply = await ctx.reply(messageManager.getMessage('webook_invalid_url'), {
+        parse_mode: 'HTML',
+        ...getBackToMainMenuButton()
+      });
+      state.lastBotMessageId = reply.message_id;
+      bookByUrlStates.set(telegramId, state);
       return true;
     }
     const fixedUrl = fixWeBookEventUrl(url);
@@ -379,13 +427,37 @@ export async function handleBookByUrlText(ctx: BotContext) {
     state.step = 2;
     bookByUrlStates.set(telegramId, state);
     console.log('[BookByUrl] URL accepted for', telegramId, 'fixedUrl:', fixedUrl);
-    await ctx.reply('✅ URL accepted. How many tickets do you want to book? (Please enter a number)', getBackToMainMenuButton());
+    const reply = await ctx.reply(
+      messageManager.getMessage('webook_url_accepted')
+        .replace('{original_url}', url)
+        .replace('{fixed_url}', fixedUrl), 
+      {
+        parse_mode: 'HTML',
+        ...getBackToMainMenuButton()
+      }
+    );
+    state.lastBotMessageId = reply.message_id;
+    bookByUrlStates.set(telegramId, state);
     return true;
   } else if (state.step === 2) {
+    // Delete the bot's previous message asking for ticket count
+    if (state.lastBotMessageId) {
+      try {
+        await ctx.deleteMessage(state.lastBotMessageId);
+      } catch (e) {
+        console.log('Could not delete bot message:', e);
+      }
+    }
+    
     // Validate ticket count
     const count = parseInt(message.text.trim(), 10);
     if (isNaN(count) || count <= 0) {
-      await ctx.reply('❌ Please enter a valid number of tickets.', getBackToMainMenuButton());
+      const reply = await ctx.reply(messageManager.getMessage('webook_invalid_ticket_count'), {
+        parse_mode: 'HTML',
+        ...getBackToMainMenuButton()
+      });
+      state.lastBotMessageId = reply.message_id;
+      bookByUrlStates.set(telegramId, state);
       return true;
     }
     state.tickets = count;
@@ -395,19 +467,30 @@ export async function handleBookByUrlText(ctx: BotContext) {
     const maxTicketsPerAccount = await getMaxTicketsAllowed(state.fixedUrl!);
     
     if (maxTicketsPerAccount === 0) {
-      await ctx.reply(`❌ No tickets are currently available for this event:\n\n${state.fixedUrl}\n\nPlease try again later.`, getBackToMainMenuButton());
-      bookByUrlStates.delete(telegramId);
+      const reply = await ctx.reply(
+        messageManager.getMessage('webook_no_tickets_available')
+          .replace('{event_url}', state.fixedUrl!)
+          .replace('{tickets_requested}', count.toString()), 
+        {
+          parse_mode: 'HTML',
+          ...getBackToMainMenuButton()
+        }
+      );
+      state.lastBotMessageId = reply.message_id;
+      bookByUrlStates.set(telegramId, state);
       return true;
     }
     
-    let infoMsg = `The event allows booking up to <b>${maxTicketsPerAccount}</b> tickets per account.`;
-    if (count > maxTicketsPerAccount) {
-      const neededAccounts = Math.ceil(count / maxTicketsPerAccount);
-      infoMsg += `\n\nYou requested <b>${count}</b> tickets. This means you need <b>${neededAccounts}</b> accounts to book all tickets.`;
-    }
+    let infoMsg = messageManager.getMessage('webook_booking_summary')
+      .replace('{event_url}', state.fixedUrl!)
+      .replace('{tickets_requested}', count.toString())
+      .replace('{max_tickets_per_account}', maxTicketsPerAccount.toString());
+      
+    infoMsg += messageManager.getMessage('webook_payment_question');
+    
     // Ask user if they want to make payment automatically
-    await ctx.reply(
-      infoMsg + '\n\nDo you want to make payment automatically?',
+    const reply = await ctx.reply(
+      infoMsg,
       {
         parse_mode: 'HTML',
         ...Markup.inlineKeyboard([
@@ -416,17 +499,13 @@ export async function handleBookByUrlText(ctx: BotContext) {
         ])
       }
     );
+    state.lastBotMessageId = reply.message_id;
+    bookByUrlStates.set(telegramId, state);
     return true;
   }
   return false;
 }
 
-// Handle Yes/No payment buttons
-export function setupWeBookBookByUrlPaymentHandlers(bot: any) {
-  bot.action('webook_book_by_url_payment_yes', (ctx: BotContext) => handleBookingProcess(ctx, true));
-  bot.action('webook_book_by_url_payment_no', (ctx: BotContext) => handleBookingProcess(ctx, false));
-}
-
 interface WebhookAccount {
   id: string;
   email: string;
@@ -439,7 +518,7 @@ async function handleBookingProcess(ctx: BotContext, withPayment: boolean) {
 
   const state = bookByUrlStates.get(telegramId);
   if (!state || !state.eventUrl || !state.tickets) {
-    await ctx.reply('Your request expired or is invalid. Please start again.');
+    await ctx.reply(messageManager.getMessage('webook_request_expired'), { parse_mode: 'HTML' });
     return;
   }
 
@@ -447,18 +526,19 @@ async function handleBookingProcess(ctx: BotContext, withPayment: boolean) {
   bookByUrlStates.set(telegramId, state);
 
   if (withPayment) {
-    await ctx.reply('💳 Please wait while we process your booking and payment...');
+    await ctx.reply(messageManager.getMessage('webook_processing_payment'), { parse_mode: 'HTML' });
   } else {
-    await ctx.reply('📝 Booking your tickets without automatic payment...');
+    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('Error fetching accounts for booking.');
+    await ctx.reply(messageManager.getMessage('webook_error_fetching_accounts'), { parse_mode: 'HTML' });
     bookByUrlStates.delete(telegramId);
     return;
   }
@@ -466,56 +546,195 @@ async function handleBookingProcess(ctx: BotContext, withPayment: boolean) {
   const availableAccounts = accounts.filter((a) => a.id && a.email && a.password);
 
   if (availableAccounts.length === 0) {
-    await ctx.reply('No active accounts with credentials available for booking.');
+    await ctx.reply(messageManager.getMessage('webook_no_available_accounts'), { parse_mode: 'HTML' });
     bookByUrlStates.delete(telegramId);
     return;
   }
 
-  await ctx.reply(`Found ${availableAccounts.length} active accounts. Starting booking for ${ticketsNeeded} tickets.`);
+  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 account of availableAccounts) {
+  for (const accountChunk of accountChunks) {
     if (ticketsObtained >= ticketsNeeded) {
-      await ctx.reply('All required tickets have been booked.');
+      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(`Using account: ${account.email}`);
+        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) {
-        await ctx.reply(`Login failed for account: ${account.email}. Trying next account.`);
-        continue;
+      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 bookedCount = await booking.bookEvent(eventUrl, withPayment);
-
-      if (bookedCount > 0) {
-        ticketsObtained += bookedCount;
-        await ctx.reply(`Successfully booked ${bookedCount} tickets with ${account.email}. Total so far: ${ticketsObtained}.`);
+      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 {
-        await ctx.reply(`Booking failed with account: ${account.email}.`);
-      }
+          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) {
-      await ctx.reply(`An error occurred while booking with ${account.email}: ${e.message}`);
+        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;
+    }
   }
 
-  let finalMessage = `Booking process finished. Total tickets obtained: ${ticketsObtained} out of ${ticketsNeeded} requested.`;
-  if (!withPayment && ticketsObtained > 0) {
-    finalMessage += ' You will need to complete payment manually.';
+  // 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' });
   }
-  await ctx.reply(finalMessage);
+
   bookByUrlStates.delete(telegramId);
 }
 
+// Handle Yes/No payment buttons
+export function setupWeBookBookByUrlPaymentHandlers(bot: any) {
+  bot.action('webook_book_by_url_payment_yes', async (ctx: BotContext) => {
+    // Delete the previous message with buttons
+    try {
+      await ctx.deleteMessage();
+    } catch (e) {
+      console.log('Could not delete previous message:', e);
+    }
+    await handleBookingProcess(ctx, true);
+  });
+  
+  bot.action('webook_book_by_url_payment_no', async (ctx: BotContext) => {
+    // Delete the previous message with buttons
+    try {
+      await ctx.deleteMessage();
+    } catch (e) {
+      console.log('Could not delete previous message:', e);
+    }
+    await handleBookingProcess(ctx, false);
+  });
+}
+
 // Helper: Validate WeBook event URL
 function isValidWeBookEventUrl(url: string): boolean {
   try {
@@ -536,28 +755,30 @@ function fixWeBookEventUrl(url: string): string {
 
 // 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 {
-    // 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);
+    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;
-    }
+  //   // 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;
+  //   // 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/utils/handlerUtils.ts

@@ -53,7 +53,7 @@ export const messageReplyHandler = (
  * @returns A function that handles the callback with proper error handling
  */
 export const callbackReplyHandler = (
-  replyFunction: (ctx: BotContext) => Promise<{message: string, options?: any}> | {message: string, options?: any}
+  replyFunction: (ctx: BotContext) => Promise<{message: string, options?: any}> | {message: string, options?: any} | null
 ) => async (ctx: BotContext) => {
   try {
     // Answer the callback query first
@@ -63,6 +63,11 @@ export const callbackReplyHandler = (
     // Execute the reply function to get message content and options
     const result = await Promise.resolve(replyFunction(ctx));
     
+    // If result is null or undefined, don't send any message
+    if (!result) {
+      return;
+    }
+    
     // Send the reply with the message and any provided options
     return await ctx.reply(result.message, result.options);
   } catch (error: any) {

src/bots/utils/keyboardUtils.ts

@@ -14,9 +14,9 @@ export const getMainMenuKeyboard = () => {
     // [Markup.button.callback(messageManager.getMessage('btn_login'), 'login')],
     // [Markup.button.callback(messageManager.getMessage('btn_terms'), 'terms')],
     [Markup.button.callback('🎭 WeBook Events', 'webook_events'),
-      Markup.button.callback('🎟️ Book Tickets by Event URL', 'webook_book_by_url')
+      // Markup.button.callback('🎟️ Book Tickets by Event URL', 'webook_book_by_url')
     ],
-    // [Markup.button.callback('🎟️ Book Tickets by Event URL', 'webook_book_by_url')],
+    [Markup.button.callback('🎟️ Book Tickets by Event URL', 'webook_book_by_url')],
     // [Markup.button.callback(messageManager.getMessage('btn_new_members'), 'new_members')],
     // [Markup.button.callback(messageManager.getMessage('btn_stats'), 'stats')],
     [Markup.button.callback(messageManager.getMessage('btn_change_language'), 'change_language')],
@@ -25,16 +25,17 @@ export const getMainMenuKeyboard = () => {
 
 export const getLoggedInMenuKeyboard = () => {
   return Markup.inlineKeyboard([
-    [Markup.button.callback('🔍 Browse Services', 'browse_services')],
+    // [Markup.button.callback('🔍 Browse Services', 'browse_services')],
     [Markup.button.callback('🎭 WeBook Events', 'webook_events')],
+    [Markup.button.callback('🎟️ Book Tickets by Event URL', 'webook_book_by_url')],
     [
-      Markup.button.callback(messageManager.getMessage('btn_profile'), 'profile'),
+      // Markup.button.callback(messageManager.getMessage('btn_profile'), 'profile'),
       Markup.button.callback(messageManager.getMessage('btn_change_language'), 'change_language')
     ],
-    [
-      Markup.button.callback(messageManager.getMessage('btn_top_up'), 'top_up_balance'),
-      Markup.button.callback(messageManager.getMessage('btn_history'), 'history')
-    ],
+    // [
+    //   Markup.button.callback(messageManager.getMessage('btn_top_up'), 'top_up_balance'),
+    //   Markup.button.callback(messageManager.getMessage('btn_history'), 'history')
+    // ],
     // [Markup.button.callback('💰 Buy with Balance', 'buy_with_balance')],
     [
       Markup.button.callback(messageManager.getMessage('btn_back'), 'main_menu')

src/bots/utils/messageManager.ts

@@ -30,6 +30,11 @@ class MessageManager {
 
   setLanguage(lang: 'ar' | 'en') {
     this.language = lang;
+    logger.info(`Language set to: ${lang}`);
+  }
+
+  getLanguage(): 'ar' | 'en' {
+    return this.language;
   }
 
   async loadMessages() {
@@ -142,7 +147,9 @@ class MessageManager {
       logger.warn(`Message not found for key: ${key}`);
       return `${key}`;
     }
-    return this.language === 'ar' ? message.ar_value : message.en_value;
+    const value = this.language === 'ar' ? message.ar_value : message.en_value;
+    logger.debug(`Retrieved message for key '${key}': ${value.substring(0, 100)}...`);
+    return value;
   }
 
   async updateMessage(key: string, arValue: string, enValue: string, description?: string) {
@@ -170,6 +177,10 @@ class MessageManager {
       throw error;
     }
   }
+
+  async reloadMessages() {
+    await this.loadMessages();
+  }
 }
 
 export const messageManager = MessageManager.getInstance(); 

src/controllers.ts

@@ -416,21 +416,64 @@ export const loginWeBook = async (req: Request, res: Response) => {
   if (!id || !email || !password) {
     return res.status(400).json({ error: 'id, email, and password are required' });
   }
+  let login: WeBookLogin | undefined;
   try {
-    // Create profile directory directly under etc/
-    const profileDir = path.join(process.cwd(), 'etc', id.toString());
-    const login = new WeBookLogin(email, password, profileDir);
+    login = new WeBookLogin(email, password, id.toString());
     const result = await login.login();
-    const is_login = !!result;
-    // Update is_login in account_webhook table
-    await updateDataInTable('account_webhook', { id, is_login });
-    return res.json({ state: { is_login } });
+    let is_login = false;
+    let message = '';
+    if (typeof result === 'string') {
+      message = result;
+      is_login = false;
+      await updateDataInTable('account_webhook', { id, is_login });
+      return res.status(200).json({
+        status: 200,
+        data: {
+          message,
+          is_login,
+          profileDir: id.toString()
+        }
+      });
+    } else if (!result) {
+      message = 'Login failed';
+      is_login = false;
+      await updateDataInTable('account_webhook', { id, is_login });
+      return res.status(200).json({
+        status: 200,
+        data: {
+          message,
+          is_login,
+          profileDir: id.toString()
+        }
+      });
+    } else {
+      is_login = true;
+      await updateDataInTable('account_webhook', { id, is_login });
+      return res.status(200).json({
+        status: 200,
+        data: {
+          message: 'Login successful',
+          is_login,
+          profileDir: id.toString()
+        }
+      });
+    }
   } catch (error: any) {
-    // On error, set is_login to false
     try {
       await updateDataInTable('account_webhook', { id, is_login: false });
     } catch {}
-    return res.status(500).json({ error: error.message || 'Login failed', state: { is_login: false } });
+    return res.status(500).json({
+      status: 500,
+      data: {
+        message: error.message || 'Login failed',
+        is_login: false,
+        profileDir: id.toString()
+      }
+    });
+  } finally {
+    if (login) {
+      await login.close();
+    }
   }
 };
 
@@ -455,11 +498,12 @@ export const signupWeBook = async (req: Request, res: Response) => {
     });
   }
 
+  let signup: WeBookSignup | undefined;
   try {
     // Create profile directory for this account
-    const profileDir = path.join(process.cwd(), 'etc', id.toString());
+    const profileDir = id.toString();
     
-    const signup = new WeBookSignup({
+    signup = new WeBookSignup({
       firstName,
       lastName,
       email,
@@ -470,21 +514,49 @@ export const signupWeBook = async (req: Request, res: Response) => {
     }, profileDir);
 
     const result = await signup.signup();
-    const is_login = !!result;
+    console.log("jhjgjh", result)
+    const is_login = !!result && typeof result !== 'string';
+    const is_register = !!result && typeof result !== 'string';
 
     // Update account status in database
     await updateDataInTable('account_webhook', { 
       id, 
-     is_login,
+      is_login,
+      is_register,
       email,
       password // Note: In production, you should hash the password
     });
 
+    if (typeof result === 'string') {
+      return sendResponse(res, 200, {
+        status: 200,
+        data: {
+          message: result,
+          is_login: false,
+          is_register: false,
+          profileDir
+        }
+      });
+    }
+
+    if (!result) {
+      return sendResponse(res, 200, {
+        status: 200,
+        data: {
+          message: 'Signup failed',
+          is_login: false,
+          is_register: false,
+          profileDir
+        }
+      });
+    }
+
     return sendResponse(res, 200, {
       status: 200,
       data: {
-        message: is_login ? 'Signup successful' : 'Signup failed',
-        is_login: is_login,
+        message: 'Signup successful',
+        is_login: true,
+        is_register: true,
         profileDir
       }
     });
@@ -493,15 +565,42 @@ export const signupWeBook = async (req: Request, res: Response) => {
     try {
       await updateDataInTable('account_webhook', { 
         id, 
-        is_login: false 
+        is_login: false,
+        is_register: false
       });
     } catch {}
     return sendResponse(res, 500, {
       status: 500,
       data: {
         message: error.message || 'Signup failed',
-        is_login: false
+        is_login: false,
+        is_register: false
       }
     });
+  } finally {
+    if (signup) {
+      await signup.close();
+    }
+  }
+};
+
+export const checkLoginWeBook = async (req: Request, res: Response) => {
+  const { id, email, password } = req.body;
+  if (!id || !email || !password) {
+    return res.status(400).json({ error: 'id, email, and password are required' });
+  }
+  try {
+    const login = new WeBookLogin(email, password, id.toString());
+    const { page } = await login.setupBrowser();
+    login.page = page;
+    const isLogin = await login.checkAlreadyLoggedIn();
+    await updateDataInTable('account_webhook', { id, is_login: isLogin });
+    await login.close();
+    return res.json({ isLogin });
+  } catch (error: any) {
+    try {
+      await updateDataInTable('account_webhook', { id, is_login: false });
+    } catch {}
+    return res.status(500).json({ error: error.message || 'Check login failed', isLogin: false });
   }
 };

src/db/supabaseHelper.ts

@@ -115,3 +115,25 @@ export const getImageUrl = async (bucket: string, imageName: string): Promise<st
     throw error;
   }
 };
+
+// Utility function to fetch all payment methods
+export const fetchAllPaymentMethods = async (): Promise<any[]> => {
+  try {
+    const { data, error } = await supabase
+      .from('payment_methods')
+      .select('*')
+      .eq('is_active', true)
+      .order('is_default', { ascending: false })
+      .order('created_at', { ascending: false });
+
+    if (error) {
+      throw error;
+    }
+
+    const camelData = data?.map(snakeToCamel) || [];
+    return camelData;
+  } catch (error: any) {
+    console.error('Error fetching payment methods:', error.message);
+    throw error;
+  }
+};

src/routes.ts

@@ -27,7 +27,8 @@ import {
   startSpecificBotEndpoint,
   stopSpecificBotEndpoint,
   loginWeBook,
-  signupWeBook
+  signupWeBook,
+  checkLoginWeBook
 } from "./controllers";
 
 export const setupRoutes = (app: any) => {
@@ -68,6 +69,7 @@ export const setupRoutes = (app: any) => {
 
   router.post("/login-webook", loginWeBook as unknown as RequestHandler);
   router.post("/signup-webook", signupWeBook as unknown as RequestHandler);
+  router.post("/check-login-webook", checkLoginWeBook as unknown as RequestHandler);
 
   app.use("/", router);
 };

src/webook/book.ts

@@ -1,5 +1,6 @@
 import { Page } from 'playwright';
 import { WeBookBase } from './webookBase';
+import { fetchAllPaymentMethods } from '../db/supabaseHelper';
 
 export class WeBookBooking extends WeBookBase {
   constructor(page: Page, profileDir?: string) {
@@ -9,14 +10,14 @@ export class WeBookBooking extends WeBookBase {
     }
   }
 
-  async bookEvent(eventUrl: string, withPayment: boolean = true): Promise<number> {
+  async bookEvent(eventUrl: string, withPayment: boolean = true): Promise<number | { ticketsCount: number, paymentUrl?: string }> {
     if (!this.page) throw new Error('Page not initialized');
     try {
       console.info(`Navigating to event booking page: ${eventUrl}`);
-       this.navigateToEventPage(eventUrl);
+      this.navigateToEventPage(eventUrl);
 
       if (!(await this.areTicketsAvailable())) {
-        return 0;
+        return withPayment ? 0 : { ticketsCount: 0, paymentUrl: undefined };
       }
 
       const ticketsCount = await this.selectMaxTickets();
@@ -25,15 +26,25 @@ export class WeBookBooking extends WeBookBase {
       await this.acceptTermsIfAvailable();
       await this.confirmAndPay();
       await this.waitForSpinnerToDisappear();
+      console.log("withPayment", withPayment)
       if (withPayment) {
-        await this.handlePayTabsPayment();
+        const paymentUrl = await this.handlePayTabsPayment();
+        
+        // Use the new method that tries multiple payment methods from Supabase
+        const paymentFilled = await this.fillPaymentFormWithSupabaseMethods();
+        if (paymentFilled) {
+          console.info('Payment form filled successfully.');
+        } else {
+          console.warn('Payment form not filled (form not found or error).');
+        }
+        return ticketsCount;
+      } else {
+        // Wait for PayTabs payment page and return its URL
+        const paymentUrl = await this.handlePayTabsPayment();
+        return { ticketsCount, paymentUrl };
       }
-
-      // Wait for a while (simulate time.sleep(330))
-      await new Promise((resolve) => setTimeout(resolve, 330 * 1000));
-      return ticketsCount;
-    } catch (e) {
-      if (e.message.includes('Tickets sold out after confirmation')) {
+    } catch (e: any) {
+      if (e.message && e.message.includes('Tickets sold out after confirmation')) {
         console.error('Booking failed: Tickets became sold out during the booking process');
         // Take a screenshot for debugging
         try {
@@ -41,10 +52,10 @@ export class WeBookBooking extends WeBookBase {
         } catch (screenshotError) {
           console.warn('Failed to take screenshot:', screenshotError);
         }
-        return 0;
+        return withPayment ? 0 : { ticketsCount: 0, paymentUrl: undefined };
       }
       console.error('Booking process failed:', e);
-      return 0;
+      return withPayment ? 0 : { ticketsCount: 0, paymentUrl: undefined };
     }
   }
 
@@ -150,7 +161,7 @@ export class WeBookBooking extends WeBookBase {
     }
   }
 
-  private async handlePayTabsPayment() {
+  private async handlePayTabsPayment(): Promise<string | undefined> {
     const paytabsPattern = 'https://secure.paytabs.sa/payment/';
     let onPaytabs = this.page.url().startsWith(paytabsPattern);
     if (!onPaytabs) {
@@ -163,13 +174,10 @@ export class WeBookBooking extends WeBookBase {
     }
     if (onPaytabs) {
       console.info('On PayTabs payment page:', this.page.url());
-      const paymentFilled = await this.fillPaymentForm('4111 1111 1111 1111', '12', '25', '123');
-      if (paymentFilled) {
-        console.info('Payment form filled successfully.');
-      } else {
-        console.warn('Payment form not filled (form not found or error).');
-      }
+      
+      return this.page.url();
     }
+    return undefined;
   }
 
   async fillPaymentForm(cardNumber: string, expMonth: string, expYear: string, cvv: string): Promise<boolean> {
@@ -196,4 +204,47 @@ export class WeBookBooking extends WeBookBase {
       return false;
     }
   }
+
+  async fillPaymentFormWithSupabaseMethods(): Promise<boolean> {
+    if (!this.page) throw new Error('Page not initialized');
+    
+    try {
+      // Fetch payment methods from Supabase
+      const paymentMethods = await fetchAllPaymentMethods();
+      
+      if (paymentMethods.length === 0) {
+        console.warn('No payment methods found in Supabase.');
+        return false;
+      }
+
+      // Try each payment method until one succeeds
+      for (let i = 0; i < paymentMethods.length; i++) {
+        const paymentMethod = paymentMethods[i];
+        console.info(`Trying payment method ${i + 1}/${paymentMethods.length}: ${paymentMethod.nameOnCard || 'Unknown'}`);
+        
+        try {
+          const success = await this.fillPaymentForm(
+            paymentMethod.cardNumber,
+            paymentMethod.expiryMonth.toString(),
+            paymentMethod.expiryYear.toString(),
+            paymentMethod.cvv
+          );
+          
+          if (success) {
+            console.info(`Payment form filled successfully with payment method: ${paymentMethod.nameOnCard || 'Unknown'}`);
+            return true;
+          }
+        } catch (error) {
+          console.warn(`Failed to use payment method ${i + 1}:`, error);
+          continue;
+        }
+      }
+      
+      console.error('All payment methods failed.');
+      return false;
+    } catch (error) {
+      console.error('Error fetching payment methods from Supabase:', error);
+      return false;
+    }
+  }
 } 

src/webook/login.ts

@@ -32,7 +32,7 @@ export class WeBookLogin extends WeBookBase {
     }
   }
 
-  private async checkLoginResult(): Promise<boolean> {
+  private async checkLoginResult(): Promise<boolean | string> {
     if (!this.page) throw new Error('Page not initialized');
     try {
       const errorMessage = this.page.locator('p.text-error');
@@ -40,7 +40,7 @@ export class WeBookLogin extends WeBookBase {
         const errorText = await errorMessage.innerText();
         console.error('Login failed:', errorText);
         await this.page.screenshot({ path: 'logs/login_failed.png' });
-        return false;
+        return errorText;
       }
 
       // Check if already at the dashboard
@@ -60,7 +60,7 @@ export class WeBookLogin extends WeBookBase {
     }
   }
 
-  private async checkAlreadyLoggedIn(): Promise<boolean> {
+  public async checkAlreadyLoggedIn(): Promise<boolean> {
     if (!this.page) throw new Error('Page not initialized');
     try {
     
@@ -101,7 +101,7 @@ export class WeBookLogin extends WeBookBase {
   }
   
 
-  async login(): Promise<Page | false> {
+  async login(): Promise<Page | false | string> {
     try {
       const { context, page } = await this.setupBrowser();
       this.page = page;
@@ -116,8 +116,11 @@ export class WeBookLogin extends WeBookBase {
       await this.page.screenshot({ path: 'logs/login-check.png', fullPage: true });
 
       await this.submitLoginForm();
-      if (await this.checkLoginResult()) {
+      const loginResult = await this.checkLoginResult();
+      if (loginResult === true) {
         return this.page;
+      } else if (typeof loginResult === 'string') {
+        return loginResult;
       } else {
         return false;
       }

src/webook/signup.ts

@@ -22,6 +22,7 @@ export class WeBookSignup extends WeBookBase {
   private async submitSignupForm() {
     if (!this.page) throw new Error('Page not initialized');
     try {
+      console.info(this.data.countryCode);
       // Fill first name
       await this.page.locator('[data-testid="auth_firstname_input"]').fill(this.data.firstName);
       
@@ -58,6 +59,14 @@ export class WeBookSignup extends WeBookBase {
         console.info('Waiting for signup to process...');
         await loadingSpinner.waitFor({ state: 'hidden' });
       }
+      // After spinner disappears, check for error message
+      const errorDiv = this.page.locator('div.text-error');
+      if (await errorDiv.isVisible()) {
+        const errorText = await errorDiv.innerText();
+        console.error('Signup error after spinner:', errorText);
+        await this.page.screenshot({ path: 'logs/signup_failed.png' });
+        return errorText;
+      }
     } catch (e) {
       console.error('Signup form submission failed:', e);
       throw e;
@@ -99,7 +108,7 @@ export class WeBookSignup extends WeBookBase {
     }
   }
 
-  async signup(): Promise<Page | false> {
+  async signup(): Promise<Page | false | string> {
     try {
       const { context, page } = await this.setupBrowser();
       this.page = page;
@@ -111,6 +120,8 @@ export class WeBookSignup extends WeBookBase {
       // Wait for a moment to allow for redirects
       await this.page.waitForTimeout(3000);
 
+      // Log the actual URL for debugging
+      console.info('Current URL after navigation:', this.page.url());
       // If we are redirected to the main page, it means we are already logged in.
       if (this.page.url().startsWith('https://webook.com/en') && !this.page.url().includes('signup')) {
         console.info('Already signed up. Redirected to main page.');
@@ -121,7 +132,14 @@ export class WeBookSignup extends WeBookBase {
       await this.handleCookies();
 
       // Submit the signup form
-      await this.submitSignupForm();
+      const submitResult = await this.submitSignupForm();
+      if (typeof submitResult === 'string') {
+        // Return the error message string up to the controller
+        return submitResult;
+      }
+      if (submitResult === false) {
+        return false;
+      }
 
       // Check the result
       if (await this.checkSignupResult()) {