all

src/bots/handlers/serviceHandlers.ts

@@ -12,7 +12,9 @@ import {
   getPricesErrorMessage,
   getSearchProductPromptMessage,
   getNoSearchResultsMessage,
-  getInvalidSearchInputMessage
+  getInvalidSearchInputMessage,
+  getSearchCountryPromptMessage,
+  getNoCountrySearchResultsMessage
 } from "../utils/messageUtils";
 import { 
   getLoggedInMenuKeyboard, 
@@ -34,7 +36,12 @@ const virtualNumberService = VirtualNumberService.getInstance();
 
 // Temporary in-memory state to track if a user is searching for a product
 interface UserSearchState {
-  waitingForProductSearch: boolean;
+  waitingForProductSearch?: boolean;
+  waitingForCountrySearch?: { // If searching for a country
+    serviceId: string;
+    sortBy?: 'price_asc'; // Preserve sorting preference
+    page: number; // Preserve current page
+  };
 }
 const userSearchStates = new Map<number, UserSearchState>();
 
@@ -86,6 +93,26 @@ export const setupServiceHandlers = (bot: any) => {
     });
   });
 
+  // Add handler for search country button
+  bot.action(/^search_country_(.+)_([a-zA-Z0-9]+|default)_(\d+)$/, async (ctx: BotContext) => {
+    await ctx.answerCbQuery();
+    const telegramId = ctx.from?.id;
+    if (!telegramId || !authService.isUserLoggedIn(telegramId, ctx)) {
+      await ctx.editMessageText(getAuthRequiredMessage(), { reply_markup: getMainMenuKeyboard().reply_markup });
+      return;
+    }
+
+    const match = ctx.match as RegExpMatchArray;
+    const serviceId = match[1];
+    const sortBy = match[2] === 'default' ? undefined : match[2] as 'price_asc';
+    const page = parseInt(match[3], 10);
+
+    userSearchStates.set(telegramId, { waitingForCountrySearch: { serviceId, sortBy, page } });
+    await ctx.editMessageText(getSearchCountryPromptMessage(), {
+      reply_markup: Markup.inlineKeyboard([Markup.button.callback('↩️ Cancel Search', `cancel_country_search_${serviceId}_${sortBy || 'default'}_${page}`)]).reply_markup
+    });
+  });
+
   // Add handler for canceling search
   bot.action('cancel_search', async (ctx: BotContext) => {
     await ctx.answerCbQuery();
@@ -96,10 +123,26 @@ export const setupServiceHandlers = (bot: any) => {
     await handleBrowseServices(ctx);
   });
 
-  // Text handler for product search input
+  // Add handler for canceling country search
+  bot.action(/^cancel_country_search_(.+)_([a-zA-Z0-9]+|default)_(\d+)$/, async (ctx: BotContext) => {
+    await ctx.answerCbQuery();
+    const telegramId = ctx.from?.id;
+    if (telegramId) {
+      userSearchStates.delete(telegramId);
+    }
+    const match = ctx.match as RegExpMatchArray;
+    const serviceId = match[1];
+    const sortBy = match[2] === 'default' ? undefined : match[2] as 'price_asc';
+    const page = parseInt(match[3], 10);
+    await handleServiceSelection(ctx, serviceId, sortBy, page);
+  });
+
+  // Text handler for product/country search input
   bot.on('text', async (ctx: BotContext) => {
     const telegramId = ctx.from?.id;
-    if (!telegramId || !userSearchStates.get(telegramId)?.waitingForProductSearch) {
+    const userState = userSearchStates.get(telegramId);
+
+    if (!telegramId || (!userState?.waitingForProductSearch && !userState?.waitingForCountrySearch)) {
       return; // Not in search state, let other text handlers process or ignore
     }
 
@@ -111,60 +154,143 @@ export const setupServiceHandlers = (bot: any) => {
 
     if (!query || query.length < 2) { // Require at least 2 characters for search
       await ctx.reply(getInvalidSearchInputMessage(), {
-        reply_markup: Markup.inlineKeyboard([Markup.button.callback('↩️ Cancel Search', 'cancel_search')]).reply_markup
+        reply_markup: Markup.inlineKeyboard([Markup.button.callback('↩️ Cancel Search', userState.waitingForProductSearch ? 'cancel_search' : `cancel_country_search_${userState.waitingForCountrySearch?.serviceId}_${userState.waitingForCountrySearch?.sortBy || 'default'}_${userState.waitingForCountrySearch?.page}`)]).reply_markup
       });
       return;
     }
 
-    // Filter products based on search query
-    const searchResults = Object.entries(fiveSimProducts).filter(([serviceId, serviceData]) => {
-      return serviceId.toLowerCase().includes(query) || serviceData.label_en.toLowerCase().includes(query);
-    });
-
     userSearchStates.delete(telegramId); // Clear search state after processing
 
-    if (searchResults.length === 0) {
-      await ctx.editMessageText(getNoSearchResultsMessage(), {
-        reply_markup: Markup.inlineKeyboard([Markup.button.callback('🔙 Back to Services', 'browse_services')]).reply_markup
+    if (userState.waitingForProductSearch) {
+      // Filter products based on search query
+      const searchResults = Object.entries(fiveSimProducts).filter(([serviceId, serviceData]) => {
+        return serviceId.toLowerCase().includes(query) || serviceData.label_en.toLowerCase().includes(query);
       });
-      return;
-    }
 
-    const buttons = [];
-    const rowSize = 2; // 2 buttons per row
-    const servicesPerPage = 20; // Same pagination as main services list
-    const totalPages = Math.ceil(searchResults.length / servicesPerPage);
-    const currentPage = 0; // Always start search results on the first page
+      if (searchResults.length === 0) {
+        await ctx.editMessageText(getNoSearchResultsMessage(), {
+          reply_markup: Markup.inlineKeyboard([Markup.button.callback('🔙 Back to Services', 'browse_services')]).reply_markup
+        });
+        return;
+      }
 
-    const startIndex = currentPage * servicesPerPage;
-    const endIndex = Math.min(startIndex + servicesPerPage, searchResults.length);
-    const pageServices = searchResults.slice(startIndex, endIndex);
+      const buttons = [];
+      const rowSize = 2; // 2 buttons per row
+      const servicesPerPage = 20; 
+      const currentPage = 0; // Always start search results on the first page
 
-    // Generate service buttons in pairs
-    for (let i = 0; i < pageServices.length; i += rowSize) {
-      const row = [];
-      for (let j = 0; j < rowSize && i + j < pageServices.length; j++) {
-        const [serviceId, serviceData] = pageServices[i + j];
-        row.push(
-          Markup.button.callback(
-            `${serviceData.icon} ${serviceData.label_en}`,
-            `service_${serviceId}`
-          )
-        );
+      const startIndex = currentPage * servicesPerPage;
+      const endIndex = Math.min(startIndex + servicesPerPage, searchResults.length);
+      const pageServices = searchResults.slice(startIndex, endIndex);
+
+      // Generate service buttons in pairs
+      for (let i = 0; i < pageServices.length; i += rowSize) {
+        const row = [];
+        for (let j = 0; j < rowSize && i + j < pageServices.length; j++) {
+          const [serviceId, serviceData] = pageServices[i + j];
+          row.push(
+            Markup.button.callback(
+              `${serviceData.icon} ${serviceData.label_en}`,
+              `service_${serviceId}`
+            )
+          );
+        }
+        buttons.push(row);
       }
-      buttons.push(row);
-    }
 
-    // Add pagination for search results (if needed, simplified for now)
-    // If you need full pagination for search results, it would involve more complex state management
-    // and modifying the callback data for pagination buttons to include the search query.
+      buttons.push([Markup.button.callback('🔙 Back to Services', 'browse_services')]);
 
-    buttons.push([Markup.button.callback('🔙 Back to Services', 'browse_services')]);
+      await ctx.reply(getServicesPaginationInfo(currentPage), {
+        parse_mode: 'HTML',
+        reply_markup: Markup.inlineKeyboard(buttons).reply_markup
+      });
 
-    await ctx.reply(getServicesPaginationInfo(currentPage), {
-      parse_mode: 'HTML',
-      reply_markup: Markup.inlineKeyboard(buttons).reply_markup
-    });
+    } else if (userState.waitingForCountrySearch) {
+      const { serviceId, sortBy, page } = userState.waitingForCountrySearch;
+      const allCountries = Object.entries(countryData); // Use all countries for search
+
+      const queryResults = allCountries.filter(([countryShortId, countryInfo]) => {
+        const searchTarget = `${countryInfo.label.toLowerCase()} ${countryInfo.flag.toLowerCase()} ${countryInfo.code.toLowerCase()} ${countryShortId.toLowerCase()}`;
+        return searchTarget.includes(query);
+      });
+
+      // Get prices for the selected service to filter countries by availability and get min/max prices
+      let productPricesForService: any = {};
+      try {
+        const fullProductPrices = await virtualNumberService.getProductPrices(serviceId);
+        if (fullProductPrices && fullProductPrices[serviceId]) {
+          productPricesForService = fullProductPrices[serviceId];
+        }
+      } catch (error: any) {
+        logger.error(`Error fetching prices for service ${serviceId} during country search: ${error.message}`);
+        await ctx.editMessageText(getServiceErrorMessage(serviceId), {
+          parse_mode: 'HTML',
+          reply_markup: Markup.inlineKeyboard([Markup.button.callback('🔙 Back to Services', 'browse_services')]).reply_markup
+        });
+        return;
+      }
+
+      const searchResults = queryResults.filter(([countryShortId, _]) => {
+        const countryOperators = productPricesForService[countryShortId];
+        // Only include countries that have available numbers for the current service
+        return countryOperators && Object.values(countryOperators).some((op: any) => op.count > 0);
+      }).map(([countryId, countryInfo]) => {
+        const operators = productPricesForService[countryId];
+        const prices = Object.values(operators)
+          .filter((op: any) => op.count > 0)
+          .map((op: any) => calculatePriceWithProfit(ctx, op.cost, 'RUB'));
+        
+        const minPrice = prices.length > 0 ? parseFloat(Math.min(...prices).toFixed(2)) : 0;
+        const maxPrice = prices.length > 0 ? parseFloat(Math.max(...prices).toFixed(2)) : 0;
+        
+        return { countryId, countryInfo, minPrice, maxPrice };
+      });
+
+      if (searchResults.length === 0) {
+        await ctx.editMessageText(getNoCountrySearchResultsMessage(), {
+          reply_markup: Markup.inlineKeyboard([Markup.button.callback('↩️ Cancel Search', `cancel_country_search_${serviceId}_${sortBy || 'default'}_${page}`)]).reply_markup
+        });
+        return;
+      }
+
+      const buttons = [];
+      const rowSize = 2;
+      const countriesPerPage = 10; 
+      const totalPages = Math.ceil(searchResults.length / countriesPerPage);
+      const currentPage = 0; 
+
+      const startIndex = currentPage * countriesPerPage;
+      const endIndex = Math.min(startIndex + countriesPerPage, searchResults.length);
+      const pageCountries = searchResults.slice(startIndex, endIndex);
+
+      for (let i = 0; i < pageCountries.length; i += rowSize) {
+        const row = [];
+        for (let j = 0; j < rowSize && i + j < pageCountries.length; j++) {
+          const { countryId, countryInfo, minPrice, maxPrice } = pageCountries[i + j];
+          
+          const priceText = minPrice === maxPrice 
+            ? `${minPrice}$`
+            : `${minPrice}$-${maxPrice}$`;
+
+          row.push(
+            Markup.button.callback(
+              `${countryInfo.flag} ${countryInfo.label} (${priceText})`,
+              `country_${serviceId}_${countryId}`
+            )
+          );
+        }
+        if (row.length > 0) {
+          buttons.push(row);
+        }
+      }
+
+      buttons.push([Markup.button.callback('↩️ Back to Countries', `cancel_country_search_${serviceId}_${sortBy || 'default'}_${page}`)]);
+
+      await ctx.reply(getCountriesListMessage(serviceId), {
+        parse_mode: 'HTML',
+        reply_markup: Markup.inlineKeyboard(buttons).reply_markup
+      });
+    }
   });
 
   // Register service selection handlers
@@ -283,7 +409,7 @@ export const handleServiceSelection = async (ctx: BotContext, service: string, s
     // Create buttons for countries with available numbers
     const buttons = [];
     const rowSize = 2; // 2 buttons per row
-    const countriesPerPage = 10; // 10 countries per page
+    const countriesPerPage = 20; // 10 countries per page
     let countries = Object.entries(servicePrices)
       .filter(([_, operators]) => {
         // Check if any operator has available numbers
@@ -324,6 +450,9 @@ export const handleServiceSelection = async (ctx: BotContext, service: string, s
     // Add sort button
     buttons.push([Markup.button.callback('Price ⬇️ (Cheapest)', `sort_countries_price_asc_${service}_${page}`)]);
 
+    // Add search country button
+    buttons.push([Markup.button.callback('🔍 Search Country', `search_country_${service}_${sortBy || 'default'}_${page}`)]);
+
     // Generate country buttons in pairs
     for (let i = 0; i < pageCountries.length; i += rowSize) {
       const row = [];

src/bots/utils/messageManager.ts

@@ -82,6 +82,14 @@ class MessageManager {
       'invalid_search_input': {
         ar_value: 'الرجاء إدخال ما لا يقل عن حرفين للبحث.',
         en_value: 'Please enter at least 2 characters to search.'
+      },
+      'search_country_prompt': {
+        ar_value: 'الرجاء إدخال اسم الدولة أو رمزها أو علمها:',
+        en_value: 'Please enter the country name, code, or flag:'
+      },
+      'no_country_search_results': {
+        ar_value: 'عذراً، لم يتم العثور على دول مطابقة لبحثك.',
+        en_value: 'Sorry, no matching countries found for your search.'
       }
     };
 

src/bots/utils/messageUtils.ts

@@ -169,4 +169,12 @@ export const getNoSearchResultsMessage = () => {
 
 export const getInvalidSearchInputMessage = () => {
   return messageManager.getMessage('invalid_search_input');
+};
+
+export const getSearchCountryPromptMessage = () => {
+  return messageManager.getMessage('search_country_prompt');
+};
+
+export const getNoCountrySearchResultsMessage = () => {
+  return messageManager.getMessage('no_country_search_results');
 };