Add application file

.gitignore

@@ -0,0 +1,53 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+d.sh
+exp.py
+ollamafreeapi/tools.py
+trash
+webook_profile
+webook_login.log
+*.log
+
+# Environment variables
+.env
+.env.*

Dockerfile

@@ -0,0 +1,30 @@
+# Use Python 3.11 as base image
+FROM python:3.11-slim
+
+# Set working directory
+WORKDIR /app
+
+# Install system dependencies required for Playwright
+RUN apt-get update && apt-get install -y \
+    wget \
+    gnupg \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first to leverage Docker cache
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Install Playwright browsers
+RUN playwright install chromium
+RUN playwright install-deps
+
+# Copy the rest of the application
+COPY . .
+
+# Expose port 7860
+EXPOSE 7860
+
+# Command to run the application
+CMD ["python", "telegram_bot.py"] 

book.py

@@ -0,0 +1,97 @@
+import time # Import the time module
+from utils import WeBookBase, logger
+
+class WeBookBooking(WeBookBase):
+    def __init__(self, page, profile_dir=None):
+        super().__init__(profile_dir, page=page)
+        if not self.page:
+             raise ValueError("A Playwright page object must be provided to WeBookBooking")
+
+    def book_event(self, event_url):
+        try:
+            logger.info(f"Navigating to event booking page: {event_url}")
+            self.page.goto(event_url, wait_until='networkidle')
+            
+            self._handle_cookies()
+            
+            # Locate and click the '+' button for the first ticket offer
+            # Locate the button containing the specific '+' SVG icon
+            try:
+                # We are looking for a button that contains an SVG with the specific path
+                plus_button = self.page.locator('button:has(svg path[d="M7 1C7 0.447715 6.55228 0 6 0C5.44772 0 5 0.447715 5 1V5H1C0.447715 5 0 5.44772 0 6C0 6.55228 0.447715 7 1 7H5V11C5 11.5523 5.44772 12 6 12C6.55228 12 7 11.5523 7 11V7H11C11.5523 7 12 6.55228 12 6C12 5.44772 11.5523 5 11 5H7V1Z"])').first
+                
+                if plus_button.is_visible():
+                    plus_button.click()
+                    logger.info("Clicked '+' button (SVG) for the first ticket offer")
+
+                
+                    # Wait for the main summary/payment button to become visible
+                    summary_button = self.page.locator('[data-testid="ticketing_tickets_go_to_summary_button"]')
+                    summary_button.wait_for(state='visible', timeout=5000) # Wait up to 5 seconds
+
+                else:
+                    logger.warning("Could not find the '+' button (SVG) for ticket selection.")
+                    return False # Exit if ticket selection failed
+
+            except Exception as click_e:
+                logger.error(f"Failed to click '+' button (SVG) or wait for summary button: {str(click_e)}")
+                return False # Exit on error
+
+            # Locate and click the main summary/payment button using its data-testid
+            if summary_button.is_visible():
+                summary_button.click()
+                logger.info("Clicked main summary/payment button (using data-testid)")
+
+                # --- New Step: Wait for and click the "Skip to Payment" button ---
+                # Use a more specific selector for the Skip to checkout button
+                skip_button = self.page.get_by_role("button", name="Skip to checkout")
+                try:
+                    skip_button.wait_for(state='visible', timeout=5000) # Wait up to 5 seconds for the skip button
+                    if skip_button.is_visible():
+                        skip_button.click()
+                        logger.info("Clicked 'Skip to Payment' button")
+                    else:
+                        logger.warning("'Skip to Payment' button not visible after waiting.")
+                        return False
+                except Exception as skip_e:
+                     logger.error(f"Failed to wait for or click 'Skip to Payment' button: {str(skip_e)}")
+                     return False # Exit on error during skip button click
+                # --- End New Step ---
+
+            else:
+                 logger.warning("Main summary/payment button not visible after waiting.")
+                 return False # Exit if summary button is not visible
+
+            # Wait for and click the terms checkbox
+            terms_checkbox = self.page.locator('[data-testid="ticketing_summary_resell_terms_checkbox"]')
+            if terms_checkbox.is_visible():
+                terms_checkbox.click()
+                logger.info("Accepted terms and conditions")
+            else:
+                 logger.warning("Could not find the terms checkbox.") # Might be critical depending on site
+                 # Consider returning False here if accepting terms is mandatory
+                 # return False
+                 
+            
+
+            # Add final step to click the Confirm & pay button
+            confirm_button = self.page.locator('[data-testid="ticketing_summary_proceed_to_payment"]')
+            try:
+                confirm_button.wait_for(state='visible', timeout=5000)
+                if confirm_button.is_visible():
+                    confirm_button.click()
+                    logger.info("Clicked 'Confirm & pay' button")
+                else:
+                    logger.warning("'Confirm & pay' button not visible after waiting.")
+                    return False
+            except Exception as confirm_e:
+                logger.error(f"Failed to wait for or click 'Confirm & pay' button: {str(confirm_e)}")
+                return False
+            
+            time.sleep(330)
+
+            return True
+            
+        except Exception as e:
+            logger.error(f"Booking process failed: {str(e)}")
+            return False

explore.py

@@ -0,0 +1,92 @@
+import requests
+import json
+
+url = "https://cdn.webook.com/"
+
+headers = {
+    "Accept": "*/*",
+    "Accept-Encoding": "gzip, deflate, br, zstd",
+    "Accept-Language": "en-US,en;q=0.9,ar;q=0.8",
+    "Content-Type": "application/json",
+    "Origin": "https://webook.com",
+    "Referer": "https://webook.com/",
+    "User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
+}
+
+payload = {
+    "query": """query getEventListing($lang:String,$limit:Int,$skip:Int,$where:EventFilter,$order:[EventOrder]){
+        eventCollection(locale:$lang,limit:$limit,skip:$skip,where:$where,order:$order){
+            total items{
+                __typename sys{id}id title subtitle slug ticketingUrlSlug 
+                image11{title sys{id publishedAt}url width height contentType}
+                image31{title sys{id publishedAt}url width height contentType}
+                startingPrice currencyCode 
+                schedule{title openTitle openDateTime closeDateTime openScheduleText}
+                isStreamingEvent zoneEntryIncluded streamingUrl buttonLabel cardButtonLabel 
+                eventType buttonLink 
+                zone{id slug title zoneLogo{title sys{id publishedAt}url width height contentType}
+                sponsorLogo{title sys{id publishedAt}url width height contentType}} 
+                location{title address city countryCode seactionHeader location{lat lon}
+                banner{title sys{id publishedAt}url width height contentType} accessibility} 
+                category{id title slug} isComingSoon organizationSlug 
+                carousalCollection(limit:10){
+                    items{title sys{id publishedAt}url width height contentType}
+                }
+            }
+        }
+    }""",
+    "variables": {
+        "order": ["order_ASC", "sys_publishedAt_DESC"],
+        "lang": "ar-SA",
+        "limit": 7,
+        "skip": 0,
+        "where": {
+            "visibility_not": "private",
+            "OR": [
+                {"schedule": {"closeDateTime_exists": False}},
+                {"schedule": {"closeDateTime_gte": "2025-05-28T22:00:00.000Z"}}
+            ],
+            "AND": [
+                {},
+                {},
+                {
+                    "OR": [
+                        {"cmsTags": {"slug_in": ["football"]}}
+                    ]
+                },
+                {},
+                {},
+                {
+                    "OR": [
+                        {
+                            "schedule": {
+                                "openDateTime_lte": "2025-05-29T20:59:59.999Z",
+                                "closeDateTime_gte": "2025-05-28T21:00:00.000Z"
+                            }
+                        },
+                        {
+                            "schedule": {
+                                "openDateTime_gte": "2025-05-28T21:00:00.000Z",
+                                "openDateTime_lte": "2025-05-29T20:59:59.999Z"
+                            }
+                        },
+                        {
+                            "schedule": {
+                                "openDateTime_lte": "2025-05-29T20:59:59.999Z",
+                                "closeDateTime_exists": False
+                            }
+                        }
+                    ]
+                },
+                {}
+            ]
+        }
+    },
+    "operationName": "getEventListing"
+}
+
+response = requests.post(url, headers=headers, json=payload)
+
+print(f"Status Code: {response.status_code}")
+print("Response JSON:")
+print(json.dumps(response.json(), indent=2, ensure_ascii=False))

login.py

@@ -0,0 +1,96 @@
+import logging
+import os
+from pathlib import Path
+from playwright.sync_api import sync_playwright
+from utils import WeBookBase, logger
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler('logs/webook_login.log'),
+        logging.StreamHandler()
+    ]
+)
+
+logger = logging.getLogger(__name__)
+
+class WeBookLogin(WeBookBase):
+    def __init__(self, email, password, profile_dir=None):
+        super().__init__(profile_dir)
+        self.email = email
+        self.password = password
+
+    def _submit_login_form(self):
+        try:
+            self.page.locator('[data-testid="auth_login_email_input"]').fill(self.email)
+            self.page.locator('#password').fill(self.password)
+            login_button = self.page.locator('[data-testid="auth_login_submit_button"]')
+            login_button.click()
+            logger.info("Login form submitted")
+            
+            loading_spinner = self.page.locator('[data-testid="circle-spinner"]')
+            if loading_spinner.is_visible():
+                logger.info("Waiting for login to process...")
+                loading_spinner.wait_for(state="hidden")
+        except Exception as e:
+            logger.error(f"Login form submission failed: {str(e)}")
+            raise
+
+    def _check_login_result(self):
+        try:
+            error_message = self.page.locator('p.text-error')
+            if error_message.is_visible():
+                error_text = error_message.inner_text()
+                logger.error(f"Login failed: {error_text}")
+                self.page.screenshot(path="login_failed.png")
+                return False
+            
+            self.page.wait_for_url("https://webook.com/en", timeout=10000)
+            logger.info("Successfully redirected to dashboard")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Login verification failed: {str(e)}")
+            return False
+
+    def _check_already_logged_in(self):
+        try:
+            # Navigate to login page
+            self.page.goto("https://webook.com/en/login", wait_until='networkidle')
+            
+            # Check if we're redirected to dashboard
+            current_url = self.page.url
+            if current_url == "https://webook.com/en":
+                logger.info("Already logged in - redirected to dashboard")
+                return True
+                
+            return False
+            
+        except Exception as e:
+            logger.error(f"Error checking login status: {str(e)}")
+            return False
+
+    def login(self):
+        try:
+            # Setup browser and get the page/context, even if using an existing one
+            self.context, self.page = self._setup_browser()
+            
+            # First check if already logged in
+            if self._check_already_logged_in():
+                return self.page # Return the page if already logged in
+                
+            logger.info("Not logged in, proceeding with login form")
+            self._handle_cookies()
+            self._submit_login_form()
+            
+            # Check login result and return page or False
+            if self._check_login_result():
+                return self.page # Return the page if login was successful
+            else:
+                return False # Return False if login failed
+            
+        except Exception as e:
+            logger.error(f"Login process failed: {str(e)}")
+            return False

main.py

@@ -0,0 +1,49 @@
+from venv import logger
+from login import WeBookLogin
+from book import WeBookBooking
+from utils import WeBookBase # Import WeBookBase for cleanup
+from dotenv import load_dotenv
+import os
+
+# Load environment variables
+load_dotenv()
+
+def main():
+    profile_dir = "./webook_profile"
+    
+    # Instantiate login and perform login
+    login = WeBookLogin(
+        email=os.getenv('WEBBOOK_EMAIL'),
+        password=os.getenv('WEBBOOK_PASSWORD'),
+        profile_dir=profile_dir
+    )
+    
+    # login() now returns the page object on success, or False on failure
+    page = login.login() 
+    
+    if page: # Check if login was successful and returned a page object
+        logger.info("Login successful, proceeding with booking.")
+        # Instantiate booking with the existing page object
+        booking = WeBookBooking(page=page, profile_dir=profile_dir)
+        event_url = "https://webook.com/en/events/mdlbeast-beast-house-ec/book"
+        booking.book_event(event_url)
+        
+        # Perform final cleanup using the context/playwright from the login object
+        # The page object is part of the context, so closing context is enough.
+        if login.context: # Check if context was created by login
+             login.context.close()
+        if login.playwright: # Check if playwright was started by login
+             login.playwright.stop()
+             logger.info("Browser closed after booking.")
+
+    else:
+        logger.error("Login failed. Cannot proceed with booking.")
+        # Cleanup should already be handled within login() on failure, but a final check
+        if login.context:
+             login.context.close()
+        if login.playwright:
+             login.playwright.stop()
+
+
+if __name__ == "__main__":
+    main() 

monitor.py

@@ -0,0 +1,101 @@
+import asyncio
+from datetime import datetime
+import logging
+from typing import Dict, List
+import json
+
+logger = logging.getLogger(__name__)
+
+class EventMonitor:
+    def __init__(self, bot):
+        self.bot = bot
+        self.monitoring_tasks: Dict[int, asyncio.Task] = {}  # user_id -> task
+        self.user_filters: Dict[int, dict] = {}  # user_id -> filters
+        self.last_events: Dict[int, List[str]] = {}  # user_id -> list of event IDs
+
+    async def start_monitoring(self, user_id: int, filters: dict):
+        """Start monitoring events for a user with given filters"""
+        if user_id in self.monitoring_tasks:
+            # Stop existing task if any
+            self.monitoring_tasks[user_id].cancel()
+        
+        # Store user filters
+        self.user_filters[user_id] = filters
+        self.last_events[user_id] = []
+        
+        # Create and start new monitoring task
+        task = asyncio.create_task(self._monitor_loop(user_id))
+        self.monitoring_tasks[user_id] = task
+        
+        return True
+
+    async def stop_monitoring(self, user_id: int):
+        """Stop monitoring events for a user"""
+        if user_id in self.monitoring_tasks:
+            self.monitoring_tasks[user_id].cancel()
+            del self.monitoring_tasks[user_id]
+            del self.user_filters[user_id]
+            del self.last_events[user_id]
+            return True
+        return False
+
+    async def _monitor_loop(self, user_id: int):
+        """Main monitoring loop"""
+        while True:
+            try:
+                filters = self.user_filters[user_id]
+                # Get current events using existing payload method
+                payload = self.bot._get_events_payload(**filters)
+                response = await self.bot._make_request(payload)
+                events = response["data"]["eventCollection"]["items"]
+                
+                # Check for new events
+                current_event_ids = [event['id'] for event in events]
+                new_events = [event for event in events 
+                            if event['id'] not in self.last_events[user_id]]
+                
+                if new_events:
+                    # Send notification for each new event
+                    for event in new_events:
+                        message = self._format_event_message(event)
+                        await self.bot.send_message(user_id, message)
+                
+                # Update last events list
+                self.last_events[user_id] = current_event_ids
+                
+                # Wait for 1 minute before next check
+                await asyncio.sleep(60)
+                
+            except asyncio.CancelledError:
+                break
+            except Exception as e:
+                logger.error(f"Error in monitor loop for user {user_id}: {e}")
+                await asyncio.sleep(60)  # Wait before retrying
+
+    def _format_event_message(self, event: dict) -> str:
+        """Format event details into a message"""
+        message_parts = [
+            "🎉 *New Event Alert!* 🎉",
+            f"🏆 *{event.get('title', 'N/A')}*",
+        ]
+        
+        if event.get('subtitle'):
+            message_parts.append(f"_{event.get('subtitle')}_")
+            
+        location = event.get('location', {}).get('title', 'N/A')
+        message_parts.append(f"📍 Location: {location}")
+        
+        price = event.get('startingPrice', 'N/A')
+        currency = event.get('currencyCode', 'N/A')
+        message_parts.append(f"💰 Starting Price: {price} {currency}")
+        
+        schedule = event.get('schedule', {})
+        if schedule.get('openDateTime'):
+            message_parts.append(f"🕒 Starts: {schedule['openDateTime']}")
+            
+        if event.get('ticketingUrlSlug'):
+            message_parts.append(
+                f"[More Info/Tickets](https://webook.com/ar/events/{event['ticketingUrlSlug']})"
+            )
+            
+        return "\n".join(message_parts) 

monitor_handlers.py

@@ -0,0 +1,65 @@
+from telegram import Update, InlineKeyboardButton, InlineKeyboardMarkup
+from telegram.ext import ContextTypes
+import logging
+
+logger = logging.getLogger(__name__)
+
+class MonitorHandlers:
+    def __init__(self, bot):
+        self.bot = bot
+
+    async def handle_country_selection(self, query, context):
+        """Handle country selection for monitoring"""
+        keyboard = [
+            [InlineKeyboardButton("🇸🇦 Saudi Arabia", callback_data='monitor_country_SA')],
+            [InlineKeyboardButton("🇦🇪 UAE", callback_data='monitor_country_AE')],
+            [InlineKeyboardButton("🇶🇦 Qatar", callback_data='monitor_country_QA')],
+            [InlineKeyboardButton("⬅️ Back", callback_data='start_monitoring')]
+        ]
+        
+        reply_markup = InlineKeyboardMarkup(keyboard)
+        await query.edit_message_text(
+            "🌍 Select a country to monitor events from:",
+            reply_markup=reply_markup
+        )
+
+    async def handle_date_selection(self, query, context):
+        """Handle date filter selection for monitoring"""
+        keyboard = [
+            [InlineKeyboardButton("☀️ Today", callback_data='monitor_date_today')],
+            [InlineKeyboardButton("🗓️ Tomorrow", callback_data='monitor_date_tomorrow')],
+            [InlineKeyboardButton("📅 This Week", callback_data='monitor_date_this_week')],
+            [InlineKeyboardButton("⬅️ Back", callback_data='start_monitoring')]
+        ]
+        
+        reply_markup = InlineKeyboardMarkup(keyboard)
+        await query.edit_message_text(
+            "📅 Select a date filter for monitoring:",
+            reply_markup=reply_markup
+        )
+
+    async def handle_category_selection(self, query, context):
+        """Handle category selection for monitoring"""
+        keyboard = [
+            [InlineKeyboardButton("🎁 Offers", callback_data='monitor_category_offers')],
+            [InlineKeyboardButton("⚽ Sports", callback_data='monitor_category_sports-events')],
+            [InlineKeyboardButton("🎭 Theater", callback_data='monitor_category_theater-and-performing-arts')],
+            [InlineKeyboardButton("⬅️ Back", callback_data='start_monitoring')]
+        ]
+        
+        reply_markup = InlineKeyboardMarkup(keyboard)
+        await query.edit_message_text(
+            "🎯 Select a category to monitor:",
+            reply_markup=reply_markup
+        )
+
+    async def handle_price_range(self, query, context):
+        """Handle price range selection for monitoring"""
+        # This would typically involve a conversation flow to get min/max prices
+        await query.edit_message_text(
+            "💰 Please enter the price range in the format:\n"
+            "min-max\n"
+            "Example: 100-500\n"
+            "Or enter 'any' for no price filter"
+        )
+        context.user_data['awaiting_price_range'] = True 

requirements.txt

@@ -0,0 +1,4 @@
+python-telegram-bot>=20.0
+requests>=2.31.0
+playwright>=1.40.0
+python-dotenv>=1.0.0 

telegram_bot.py

@@ -0,0 +1,778 @@
+import logging
+from telegram import CallbackQuery, Update, InlineKeyboardButton, InlineKeyboardMarkup
+from telegram.ext import Application, CommandHandler, CallbackQueryHandler, ContextTypes, MessageHandler, filters
+import requests
+import json
+from datetime import datetime, timedelta
+from monitor import EventMonitor
+from dotenv import load_dotenv
+import os
+
+# Load environment variables
+load_dotenv()
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler('logs/telegram_bot.log'),
+        logging.StreamHandler()
+    ]
+)
+logger = logging.getLogger(__name__)
+
+class WeBookBot:
+    def __init__(self, token):
+        self.token = token
+        self.url = "https://cdn.webook.com/"
+        self.headers = {
+            "Accept": "*/*",
+            "Accept-Encoding": "gzip, deflate, br, zstd",
+            "Accept-Language": "en-US,en;q=0.9,ar;q=0.8",
+            "Content-Type": "application/json",
+            "Origin": "https://webook.com",
+            "Referer": "https://webook.com/",
+            "User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
+        }
+        self.monitor = EventMonitor(self)
+
+    def _get_events_payload(self, category=None, date_filter=None, price_min=None, price_max=None, zones=None, country_code="SA", limit=20, skip=0):
+        """Generate the payload for the events API request with flexible filtering using the getShows query."""
+        now = datetime.now()
+        tomorrow = now + timedelta(days=1)
+        end_of_week = now + timedelta(days=7)
+
+        # --- Construct Date Filter Clause (based on the structure from the new query) ---
+        # The new query uses an OR condition for schedules that includes
+        # events without a close date or those ending after a certain time,
+        # combined with specific date range checks.
+        date_schedule_or_clauses = []
+
+        # Add the clause for events without a close date or ending from now onwards
+        # (Adjusting "2025-05-28T22:00:00.000Z" to a dynamic current time or relevant start point)
+        # Let's use the start of today as a general lower bound for events that should be considered "current"
+        start_of_today = now.replace(hour=0, minute=0, second=0, microsecond=0)
+        date_schedule_or_clauses.append({
+            "OR": [
+                {"schedule":{"closeDateTime_exists":False}},
+                {"schedule":{"closeDateTime_gte": start_of_today.strftime("%Y-%m-%dT%H:%M:%S.000Z")}}
+            ]
+        })
+
+
+        # Add specific date range clause based on date_filter
+        date_range_and_clause = {}
+        if date_filter == 'today':
+            start_of_day = now.replace(hour=0, minute=0, second=0, microsecond=0)
+            end_of_day = now.replace(hour=23, minute=59, second=59, microsecond=999999)
+             # Events active at any point today
+            date_range_and_clause = {
+                 "AND": [
+                     {"schedule": {"openDateTime_lte": end_of_day.strftime("%Y-%m-%dT%H:%M:%S.000Z")}},
+                     {"schedule": {"closeDateTime_gte": start_of_day.strftime("%Y-%m-%dT%H:%M:%S.000Z")}}
+                 ]
+             }
+        elif date_filter == 'tomorrow':
+            tomorrow_start = tomorrow.replace(hour=0, minute=0, second=0, microsecond=0)
+            tomorrow_end = tomorrow.replace(hour=23, minute=59, second=59, microsecond=999999)
+            # Events active at any point tomorrow
+            date_range_and_clause = {
+                 "AND": [
+                     {"schedule": {"openDateTime_lte": tomorrow_end.strftime("%Y-%m-%dT%H:%M:%S.000Z")}},
+                     {"schedule": {"closeDateTime_gte": tomorrow_start.strftime("%Y-%m-%dT%H:%M:%S.000Z")}}
+                 ]
+             }
+        elif date_filter == 'this_week':
+            start_of_week = now.replace(hour=0, minute=0, second=0, microsecond=0)
+            end_of_week = end_of_week.replace(hour=23, minute=59, second=59, microsecond=999999)
+             # Events active at any point this week
+            date_range_and_clause = {
+                 "AND": [
+                     {"schedule": {"openDateTime_lte": end_of_week.strftime("%Y-%m-%dT%H:%M:%S.000Z")}},
+                     {"schedule": {"closeDateTime_gte": start_of_week.strftime("%Y-%m-%dT%H:%M:%S.000Z")}}
+                 ]
+             }
+
+        if date_range_and_clause:
+             date_schedule_or_clauses.append(date_range_and_clause)
+
+
+        # --- Construct Category Filter Clause ---
+        category_clause = {}
+        if category: # category can be a single slug or a list of slugs
+            if isinstance(category, str):
+                 category = [category]
+            # The new query uses 'category' with 'slug_in' directly within an OR in the main AND
+            category_clause = {"OR": [{"category": {"slug_in": category}}]} # Changed cmsTags to category
+
+
+        # --- Construct Price Filter Clause ---
+        price_clause = {}
+        price_and_clauses = []
+        if price_min is not None:
+            price_and_clauses.append({"startingPrice_gte": price_min})
+        if price_max is not None:
+            price_and_clauses.append({"startingPrice_lte": price_max})
+        if price_and_clauses:
+            price_clause = {"AND": price_and_clauses}
+
+
+        # --- Construct Zone Filter Clause ---
+        zone_clause = {}
+        if zones: # zones should be a list of slugs
+             zone_clause = {"OR":[{"zone":{"slug_in": zones}}]}
+
+        # --- Construct Country Filter Clause ---
+        country_clause = {}
+        if country_code:
+             country_clause = {"OR":[{"location":{"countryCode": country_code}}]}
+
+
+        # --- Build the main 'AND' array for the 'where' clause ---
+        # Following the structure of the provided query payload
+        and_clauses = []
+
+        # Add the zone filter if present
+        if zone_clause:
+            and_clauses.append(zone_clause)
+
+        # Add the category filter if present
+        if category_clause:
+            and_clauses.append(category_clause)
+
+        and_clauses.append({}) # Placeholder like in the example
+
+        # Add the price filter if present
+        if price_clause:
+            and_clauses.append(price_clause)
+
+        and_clauses.append({}) # Placeholder like in the example
+
+        # Add the combined date schedule OR clause if it has content
+        if date_schedule_or_clauses:
+            # If only the 'closeDateTime_exists' part is present, don't wrap in an extra OR
+            if len(date_schedule_or_clauses) == 1 and "OR" in date_schedule_or_clauses[0]:
+                 and_clauses.append(date_schedule_or_clauses[0])
+            else:
+                 and_clauses.append({"OR": date_schedule_or_clauses})
+
+        # Add the country filter if present
+        if country_clause:
+            and_clauses.append(country_clause)
+
+
+        # Filter out empty placeholder clauses, but be careful if a placeholder is intended
+        # Based on the example, there seem to be two empty placeholders that are kept.
+        # Let's keep any empty dictionaries explicitly added.
+        # and_clauses = [clause for clause in and_clauses if clause] # Removed this line to keep explicit {}
+
+
+        # --- Construct the final 'where' clause ---
+        where_clause = {
+            "visibility_not": "private",
+            # The top-level OR from the example, handling events without end date or ending from now
+            # We've integrated this logic into date_schedule_or_clauses now, so this is redundant here
+            # "OR": [
+            #      {"schedule":{"closeDateTime_exists":False}},
+            #      {"schedule":{"closeDateTime_gte": now.strftime("%Y-%m-%dT%H:%M:%S.000Z")}}
+            # ],
+        }
+
+        if and_clauses:
+            where_clause["AND"] = and_clauses
+
+
+        return {
+            "query": """query getEventListing($lang:String,$limit:Int,$skip:Int,$where:EventFilter,$order:[EventOrder]){
+                eventCollection(locale:$lang,limit:$limit,skip:$skip,where:$where,order:$order){
+                    total items{
+                        __typename sys{id}id title subtitle slug ticketingUrlSlug 
+                        image11{title sys{id publishedAt}url width height contentType}
+                        image31{title sys{id publishedAt}url width height contentType}
+                        startingPrice currencyCode 
+                        schedule{title openTitle openDateTime closeDateTime openScheduleText}
+                        isStreamingEvent zoneEntryIncluded streamingUrl buttonLabel cardButtonLabel 
+                        eventType buttonLink 
+                        zone{id slug title zoneLogo{title sys{id publishedAt}url width height contentType}
+                        sponsorLogo{title sys{id publishedAt}url width height contentType}} 
+                        location{title address city countryCode seactionHeader location{lat lon}
+                        banner{title sys{id publishedAt}url width height contentType} accessibility} 
+                        category{id title slug} isComingSoon organizationSlug 
+                        carousalCollection(limit:10){
+                            items{title sys{id publishedAt}url width height contentType}
+                        }
+                    }
+                }
+            }""",
+            "variables": {
+                "order": ["sys_publishedAt_DESC"],
+                "lang": "ar-SA",
+                "limit": limit,
+                "skip": skip,
+                "where": where_clause,
+            },
+            "operationName": "getEventListing"
+        }
+
+    async def start_command(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
+        """Handle the /start command"""
+        # Store default filters in context user_data if they don't exist
+        if 'category' not in context.user_data:
+            context.user_data['category'] = None # Or a default category slug if needed
+        if 'date_filter' not in context.user_data:
+            context.user_data['date_filter'] = 'today' # Default date filter
+        # Add placeholders for other filters
+        if 'price_min' not in context.user_data:
+            context.user_data['price_min'] = None
+        if 'price_max' not in context.user_data:
+            context.user_data['price_max'] = None
+        if 'zones' not in context.user_data:
+            context.user_data['zones'] = None # Or a list of default zone slugs if needed
+        if 'country_code' not in context.user_data:
+             context.user_data['country_code'] = 'SA' # Default country
+
+        keyboard = [
+            [
+                InlineKeyboardButton("☀️ اليوم", callback_data='date_today'),
+                InlineKeyboardButton("🗓️ غداً", callback_data='date_tomorrow'),
+                InlineKeyboardButton("📅 هذا الأسبوع", callback_data='date_this_week')
+            ],
+            [
+                InlineKeyboardButton("🎁 العروض", callback_data='category_offers'),
+                InlineKeyboardButton("⚽ الرياضة", callback_data='category_sports-events')
+            ],
+            [
+                InlineKeyboardButton("🎭 المسرح والفنون الأدائية", callback_data='category_theater-and-performing-arts'),
+                InlineKeyboardButton("⛰️ الأنشطة والمغامرات", callback_data='category_activities-adventures')
+            ],
+            [
+                InlineKeyboardButton("🎶 موسیقی", callback_data='category_music-events'),
+                InlineKeyboardButton("✨ التجارب", callback_data='category_experience')
+            ],
+            [
+                InlineKeyboardButton("🍽️ المطاعم", callback_data='category_restaurant-and-cafe')
+            ],
+            # Add buttons for other filters would be complex here.
+            # You might consider a "Filter Options" button that leads to a new message
+            # with more specific filter buttons or instructions.
+            # For now, we just keep the category and date buttons.
+            [
+                InlineKeyboardButton("✅ Show Events with Current Filters", callback_data='show_events')
+            ],
+             [
+                InlineKeyboardButton("🔄 Reset Filters", callback_data='reset_filters')
+             ],
+             [
+                InlineKeyboardButton("🔍 Start Event Monitoring", callback_data='start_monitoring'),
+                InlineKeyboardButton("⏹️ Stop Monitoring", callback_data='stop_monitoring')
+             ]
+        ]
+        reply_markup = InlineKeyboardMarkup(keyboard)
+
+        # Display current filters in the message
+        current_filters_text = self._get_current_filters_text(context.user_data)
+
+        await update.message.reply_text(
+            f'Welcome to WeBook Events Bot! 🎉\n'
+            f'Please select filters or "Show Events":\n{current_filters_text}',
+            reply_markup=reply_markup
+        )
+
+    async def button_callback(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
+        """Handle button callbacks"""
+        query = update.callback_query
+        await query.answer()
+
+        try:
+            callback_data = query.data
+
+            # --- Handle Filter Button Presses ---
+            if callback_data.startswith('category_'):
+                selected_category = callback_data.replace('category_', '')
+                # Toggle category selection (assuming single selection for simplicity for now)
+                if context.user_data.get('category') == selected_category:
+                     context.user_data['category'] = None # Deselect
+                else:
+                     context.user_data['category'] = selected_category # Select
+                # Update the message to reflect the selected filter
+                current_filters_text = self._get_current_filters_text(context.user_data)
+                await query.edit_message_text(
+                    f'Welcome to WeBook Events Bot! 🎉\n'
+                    f'Please select filters or "Show Events":\n{current_filters_text}',
+                    reply_markup=query.message.reply_markup # Keep the existing buttons
+                )
+                return # Don't fetch events yet
+
+            elif callback_data.startswith('date_'):
+                selected_date_filter = callback_data.replace('date_', '')
+                # Toggle date filter selection (assuming single selection)
+                if context.user_data.get('date_filter') == selected_date_filter:
+                     # Decide if you want to allow deselecting date, or keep a default
+                     # For now, let's allow changing but not deselecting to None
+                     pass # Do nothing if same button clicked again
+                else:
+                     context.user_data['date_filter'] = selected_date_filter # Select
+                # Update the message to reflect the selected filter
+                current_filters_text = self._get_current_filters_text(context.user_data)
+                await query.edit_message_text(
+                     f'Welcome to WeBook Events Bot! 🎉\n'
+                     f'Please select filters or "Show Events":\n{current_filters_text}',
+                     reply_markup=query.message.reply_markup # Keep the existing buttons
+                 )
+                return # Don't fetch events yet
+
+            elif callback_data == 'reset_filters':
+                # Reset all filters to default
+                context.user_data['category'] = None
+                context.user_data['date_filter'] = 'tomorrow'
+                context.user_data['price_min'] = None
+                context.user_data['price_max'] = None
+                context.user_data['zones'] = None
+                context.user_data['country_code'] = 'SA'
+                # Update the message to reflect the reset filters
+                current_filters_text = self._get_current_filters_text(context.user_data)
+                await query.edit_message_text(
+                     f'Welcome to WeBook Events Bot! 🎉\n'
+                     f'Filters have been reset. Please select filters or "Show Events":\n{current_filters_text}',
+                     reply_markup=query.message.reply_markup # Keep the existing buttons
+                 )
+                return # Don't fetch events yet
+
+            # --- Handle Pagination Button Presses ---
+            elif callback_data.startswith('page_'):
+                 try:
+                    # callback_data will be 'page_X' where X is the new skip value
+                    new_skip = int(callback_data.replace('page_', ''))
+                    # Get current filters and total events from user_data
+                    current_category = context.user_data.get('category')
+                    current_date_filter = context.user_data.get('date_filter')
+                    current_price_min = context.user_data.get('price_min')
+                    current_price_max = context.user_data.get('price_max')
+                    current_zones = context.user_data.get('zones')
+                    current_country_code = context.user_data.get('country_code')
+                    current_limit = 10 # Assuming limit is always 20 for pagination
+
+                    # Update skip value in user_data
+                    context.user_data['skip'] = new_skip
+
+                    # Fetch events for the new page
+                    payload = self._get_events_payload(
+                        category=current_category,
+                        date_filter=current_date_filter,
+                        price_min=current_price_min,
+                        price_max=current_price_max,
+                        zones=current_zones,
+                        country_code=current_country_code,
+                        limit=current_limit,
+                        skip=new_skip # Use the new skip value
+                    )
+
+                    response = requests.post(self.url, headers=self.headers, json=payload)
+                    response.raise_for_status()
+
+                    events = response.json()["data"]["eventCollection"]["items"]
+                    total_events = response.json()["data"]["eventCollection"]["total"] # Get total count
+
+                    # Indicate current filters applied in the response message
+                    filter_info = self._get_current_filters_text(context.user_data)
+
+                    if not events:
+                         # This shouldn't happen if total_events > 0, but as a fallback
+                        await query.edit_message_text(f"No events found for this page.\n{filter_info}")
+                        return
+
+                    # Format events into a readable card list with numbers
+                    message_parts = [f"🎫 Upcoming Events (Filtered - Page {int(new_skip/current_limit) + 1}/{int(total_events/current_limit) + (1 if total_events % current_limit > 0 else 0)} of {total_events}):\n{filter_info}\n"] # Add page info and total count
+
+                    for i, event in enumerate(events):
+                         # Display event number based on the current page and index
+                         event_number = new_skip + i + 1
+                         message_parts.append(f"--- Event {event_number} ---") # Separator for cards
+                         message_parts.append(f"🏆 *{event.get('title', 'N/A')}*") # Bold title
+                         if event.get('subtitle'):
+                             message_parts.append(f"_{event.get('subtitle')}_") # Italic subtitle
+
+                         location_title = event.get('location', {}).get('title', 'N/A')
+                         message_parts.append(f"📍 Location: {location_title}")
+
+                         price = event.get('startingPrice', 'N/A')
+                         currency = event.get('currencyCode', 'N/A')
+                         message_parts.append(f"💰 Starting Price: {price} {currency}") # Price info
+
+                         # Display schedule dates more clearly
+                         open_date = event.get('schedule', {}).get('openDateTime')
+                         close_date = event.get('schedule', {}).get('closeDateTime')
+                         schedule_text = "🕒 Schedule: "
+                         if open_date:
+                              try:
+                                 open_dt = datetime.fromisoformat(open_date.replace('Z', '+00:00'))
+                                 schedule_text += f"Starts: {open_dt.strftime('%Y-%m-%d %H:%M')}"
+                              except ValueError:
+                                  schedule_text += f"Starts: {open_date}"
+                         if close_date:
+                              try:
+                                 close_dt = datetime.fromisoformat(close_date.replace('Z', '+00:00'))
+                                 schedule_text += f", Ends: {close_dt.strftime('%Y-%m-%d %H:%M')}"
+                              except ValueError:
+                                  schedule_text += f", Ends: {close_date}"
+                         if not open_date and not close_date:
+                              schedule_text += "Info Not Available"
+                         message_parts.append(schedule_text)
+
+                         # Optional: Add a link if available
+                         ticketing_slug = event.get('ticketingUrlSlug')
+                         if ticketing_slug and ticketing_slug != 'N/A':
+                              message_parts.append(f"[More Info/Tickets](https://webook.com/ar/events/{ticketing_slug})")
+
+
+                         message_parts.append("") # Add an empty line for spacing between cards
+
+                    # Add pagination and select buttons below the list
+                    pagination_buttons = []
+                    # Check if there's a previous page
+                    if new_skip > 0:
+                         pagination_buttons.append(InlineKeyboardButton("⬅️ Back", callback_data=f'page_{max(0, new_skip - current_limit)}'))
+                    # Check if there's a next page
+                    if new_skip + len(events) < total_events:
+                         pagination_buttons.append(InlineKeyboardButton("➡️ Next", callback_data=f'page_{new_skip + current_limit}'))
+
+                    # Add the "Select Event" button
+                    select_button = [InlineKeyboardButton("👆 Select Event by Number", callback_data='prompt_select_event')] # New callback data
+
+                    # Combine pagination and select buttons
+                    keyboard = [pagination_buttons] if pagination_buttons else []
+                    keyboard.append(select_button)
+                    reply_markup = InlineKeyboardMarkup(keyboard)
+
+
+                    # Join all parts to form the final message
+                    message = "\n".join(message_parts)
+
+                    # Send the formatted message and update the buttons
+                    await query.edit_message_text(text=message, reply_markup=reply_markup, parse_mode='Markdown', disable_web_page_preview=True) # Use Markdown for bold/italic
+
+                 except (ValueError, TypeError) as e:
+                    logger.error(f"Error parsing page number from callback data: {e}")
+                    await query.edit_message_text("Sorry, there was an error processing the page request.")
+                 except Exception as e:
+                    logger.error(f"Error fetching paginated events: {str(e)}")
+                    await query.edit_message_text(
+                         "Sorry, there was an error fetching the next page of events. Please try again later."
+                    )
+                 return # Handled pagination, return
+
+
+            # --- Handle "Show Events" Button Press ---
+            elif callback_data == 'show_events':
+                # Fetch events with the selected filters from user_data
+                current_category = context.user_data.get('category')
+                current_date_filter = context.user_data.get('date_filter')
+                current_price_min = context.user_data.get('price_min')
+                current_price_max = context.user_data.get('price_max')
+                current_zones = context.user_data.get('zones')
+                current_country_code = context.user_data.get('country_code')
+
+                # Reset skip to 0 for a new search
+                context.user_data['skip'] = 0
+                current_limit = 20
+
+                payload = self._get_events_payload(
+                    category=current_category,
+                    date_filter=current_date_filter,
+                    price_min=current_price_min,
+                    price_max=current_price_max,
+                    zones=current_zones,
+                    country_code=current_country_code,
+                    limit=current_limit, # Pass limit
+                    skip=0 # Start from the first page
+                )
+
+                response = requests.post(self.url, headers=self.headers, json=payload)
+                response.raise_for_status()
+
+                events = response.json()["data"]["eventCollection"]["items"]
+                total_events = response.json()["data"]["eventCollection"]["total"] # Get total count
+
+                # Indicate current filters applied in the response message
+                filter_info = self._get_current_filters_text(context.user_data)
+
+                if not events:
+                    await query.edit_message_text(f"No events found for the selected filters.\n{filter_info}")
+                    return
+
+                # Store total events for pagination reference
+                context.user_data['total_events'] = total_events
+                # Store the currently displayed events to easily retrieve details when selecting by number
+                context.user_data['current_event_list'] = events
+
+
+                # Format events into a readable card list with numbers
+                message_parts = [f"🎫 Upcoming Events (Filtered - Page 1/{int(total_events/current_limit) + (1 if total_events % current_limit > 0 else 0)} of {total_events}):\n{filter_info}\n"] # Add page info and total count
+
+                for i, event in enumerate(events):
+                    # Display event number based on the current page (always 1 for initial show) and index
+                    event_number = context.user_data['skip'] + i + 1
+                    message_parts.append(f"--- Event {event_number} ---") # Separator for cards
+                    message_parts.append(f"🏆 *{event.get('title', 'N/A')}*") # Bold title
+                    if event.get('subtitle'):
+                        message_parts.append(f"_{event.get('subtitle')}_") # Italic subtitle
+
+                    location_title = event.get('location', {}).get('title', 'N/A')
+                    message_parts.append(f"📍 Location: {location_title}")
+
+                    price = event.get('startingPrice', 'N/A')
+                    currency = event.get('currencyCode', 'N/A')
+                    message_parts.append(f"💰 Starting Price: {price} {currency}") # Price info
+
+                    # Display schedule dates more clearly
+                    open_date = event.get('schedule', {}).get('openDateTime')
+                    close_date = event.get('schedule', {}).get('closeDateTime')
+                    schedule_text = "🕒 Schedule: "
+                    if open_date:
+                         try:
+                            open_dt = datetime.fromisoformat(open_date.replace('Z', '+00:00'))
+                            schedule_text += f"Starts: {open_dt.strftime('%Y-%m-%d %H:%M')}"
+                         except ValueError:
+                             schedule_text += f"Starts: {open_date}"
+                    if close_date:
+                         try:
+                            close_dt = datetime.fromisoformat(close_date.replace('Z', '+00:00'))
+                            schedule_text += f", Ends: {close_dt.strftime('%Y-%m-%d %H:%M')}"
+                         except ValueError:
+                             schedule_text += f", Ends: {close_date}"
+                    if not open_date and not close_date:
+                         schedule_text += "Info Not Available"
+                    message_parts.append(schedule_text)
+
+                    # Optional: Add a link if available
+                    ticketing_slug = event.get('ticketingUrlSlug')
+                    if ticketing_slug and ticketing_slug != 'N/A':
+                         message_parts.append(f"[More Info/Tickets](https://webook.com/ar/events/{ticketing_slug})")
+
+
+                    message_parts.append("") # Add an empty line for spacing between cards
+
+                # Add pagination and select buttons below the list
+                pagination_buttons = []
+                # Check if there's a next page on the initial load
+                if len(events) < total_events:
+                     pagination_buttons.append(InlineKeyboardButton("➡️ Next", callback_data=f'page_{current_limit}')) # Next page starts after the first limit
+
+                # Add the "Select Event" button
+                select_button = [InlineKeyboardButton("👆 Select Event by Number", callback_data='prompt_select_event')] # New callback data
+
+                # Combine pagination and select buttons
+                keyboard = [pagination_buttons] if pagination_buttons else []
+                keyboard.append(select_button)
+                reply_markup = InlineKeyboardMarkup(keyboard)
+
+
+                # Join all parts to form the final message
+                message = "\n".join(message_parts)
+
+                # Send the formatted message and update the buttons
+                await query.edit_message_text(text=message, reply_markup=reply_markup, parse_mode='Markdown', disable_web_page_preview=True) # Use Markdown for bold/italic
+
+
+            # --- Handle Prompt Select Event Button Press ---
+            elif callback_data == 'prompt_select_event':
+                 await query.edit_message_text(
+                     f"{query.message.text_markdown_v2}\n\n" # Keep the existing event list
+                     f"Please reply with the number of the event you want to select (e.g., `1`, `5`, `12`)." # Prompt the user
+                     # Note: We cannot keep inline buttons here and also wait for a text reply easily.
+                     # A full ConversationHandler is needed for that. For simplicity,
+                     # we remove the inline buttons and expect a text reply.
+                     # You might want to add a "Cancel" button if you implement ConversationHandler.
+                 )
+                 # You might set a state here in user_data if you implement a MessageHandler
+                 context.user_data['awaiting_event_number'] = True
+
+            elif callback_data == 'start_monitoring':
+                # Start monitoring setup flow
+                await self._start_monitoring_setup(query, context)
+            elif callback_data == 'stop_monitoring':
+                # Stop monitoring
+                user_id = query.from_user.id
+                if await self.monitor.stop_monitoring(user_id):
+                    await query.edit_message_text(
+                        "✅ Event monitoring stopped successfully."
+                    )
+                else:
+                    await query.edit_message_text(
+                        "❌ No active monitoring found."
+                    )
+            else:
+                # Handle other potential buttons here if needed
+                await query.edit_message_text("Unknown button pressed.")
+                return
+
+
+        except Exception as e:
+            logger.error(f"Error processing callback: {str(e)}")
+            logger.error(f"Response content: {response.text if 'response' in locals() else 'No response'}")
+            await query.edit_message_text(
+                "Sorry, there was an error fetching the events. Please try again later."
+            )
+
+    async def _start_monitoring_setup(self, query: CallbackQuery, context: ContextTypes.DEFAULT_TYPE):
+        """Start the monitoring setup process"""
+        keyboard = [
+            [InlineKeyboardButton("🌍 Select Country", callback_data='monitor_country')],
+            [InlineKeyboardButton("📅 Select Date Filter", callback_data='monitor_date')],
+            [InlineKeyboardButton("🎯 Select Category", callback_data='monitor_category')],
+            [InlineKeyboardButton("💰 Set Price Range", callback_data='monitor_price')],
+            [InlineKeyboardButton("✅ Start Monitoring", callback_data='confirm_monitoring')]
+        ]
+        
+        reply_markup = InlineKeyboardMarkup(keyboard)
+        await query.edit_message_text(
+            "🔍 *Event Monitoring Setup*\n\n"
+            "Please configure your monitoring preferences:",
+            reply_markup=reply_markup,
+            parse_mode='Markdown'
+        )
+        
+        # Initialize monitoring filters in user_data
+        context.user_data['monitoring_filters'] = {
+            'country_code': 'SA',
+            'date_filter': 'today',
+            'category': None,
+            'price_min': None,
+            'price_max': None
+        }
+
+    def _get_current_filters_text(self, user_data):
+        """Helper function to generate text summarizing current filters."""
+        category = user_data.get('category')
+        date_filter = user_data.get('date_filter')
+        price_min = user_data.get('price_min')
+        price_max = user_data.get('price_max')
+        zones = user_data.get('zones')
+        country_code = user_data.get('country_code')
+
+        filter_parts = []
+        filter_parts.append(f"Date: {date_filter.replace('_', ' ').title() if date_filter else 'Any'}")
+        filter_parts.append(f"Category: {category if category else 'All'}")
+
+        if price_min is not None or price_max is not None:
+            price_text = "Price: "
+            if price_min is not None:
+                price_text += f"From {price_min} "
+            if price_max is not None:
+                price_text += f"To {price_max}"
+            filter_parts.append(price_text)
+
+        if zones:
+            filter_parts.append(f"Zones: {', '.join(zones)}")
+
+        if country_code:
+             filter_parts.append(f"Country: {country_code}")
+
+        return "Current Filters:\n" + "\n".join(filter_parts)
+
+    async def handle_event_number_input(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
+        """Handle the user's reply with an event number."""
+        # Check if the bot is expecting an event number from this user
+        if context.user_data.get('awaiting_event_number'):
+            try:
+                event_number_str = update.message.text.strip()
+                event_number = int(event_number_str)
+
+                # Get the current list of events displayed to the user (this is just the current page)
+                # Note: This logic is simplified. A robust solution should fetch the event
+                # details based on the global index (event_number) and the full search results.
+                # For now, let's try to find the event in the *currently displayed* list.
+                current_events_on_page = context.user_data.get('current_event_list', [])
+                current_skip = context.user_data.get('skip', 0)
+
+                # Find the event corresponding to the number on the current page
+                # event_number is 1-based global index. We need the 0-based index on the current page.
+                event_index_on_page = event_number - 1 - current_skip
+
+                if 0 <= event_index_on_page < len(current_events_on_page):
+                    selected_event = current_events_on_page[event_index_on_page]
+                    # Found the event. Now you can ask "what offer want" or proceed to booking.
+                    # For now, just confirm the selection.
+                    await update.message.reply_text(
+                        f"You selected event number {event_number}:\n"
+                        f"🏆 *{selected_event.get('title', 'N/A')}*\n"
+                        f"📍 Location: {selected_event.get('location', {}).get('title', 'N/A')}\n"
+                        f"What offer would you like to select for this event?" # Placeholder for next step
+                        , parse_mode='Markdown'
+                    )
+                    # Reset the state
+                    context.user_data['awaiting_event_number'] = False
+                    context.user_data.pop('current_event_list', None) # Clear temporary data
+                    context.user_data.pop('skip', None)
+                    context.user_data.pop('total_events', None)
+
+
+                else:
+                    # Number is out of range for the current page or invalid based on global index
+                    await update.message.reply_text(
+                         f"Invalid event number '{event_number_str}'. Please reply with a number from the list above."
+                         # You might want to redisplay the list or provide a "Cancel" option.
+                    )
+                    # Keep state active to allow another attempt
+
+            except ValueError:
+                # User did not send a valid number
+                await update.message.reply_text(
+                    f"That doesn't look like a number. Please reply with the number of the event you want to select."
+                    # Keep state active
+                )
+            except Exception as e:
+                 logger.error(f"Error handling event number input: {e}")
+                 await update.message.reply_text("Sorry, there was an error processing your selection.")
+                 # Reset state on error
+                 context.user_data['awaiting_event_number'] = False
+                 context.user_data.pop('current_event_list', None)
+                 context.user_data.pop('skip', None)
+                 context.user_data.pop('total_events', None)
+
+    async def send_message(self, user_id: int, message: str):
+        """Helper method to send messages to users"""
+        try:
+            await self.application.bot.send_message(
+                chat_id=user_id,
+                text=message,
+                parse_mode='Markdown',
+                disable_web_page_preview=True
+            )
+        except Exception as e:
+            logger.error(f"Error sending message to user {user_id}: {e}")
+
+    async def _make_request(self, payload: dict):
+        """Make API request to WeBook"""
+        response = requests.post(self.url, headers=self.headers, json=payload)
+        response.raise_for_status()
+        return response.json()
+
+    def run(self):
+        """Run the bot"""
+        try:
+            application = Application.builder().token(self.token).build()
+            
+            # Add handlers
+            application.add_handler(CommandHandler("start", self.start_command))
+            application.add_handler(CallbackQueryHandler(self.button_callback))
+            # Add a MessageHandler for text input to handle event number selection
+            application.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, self.handle_event_number_input)) # Listen for non-command text
+            
+            # Start the bot
+            logger.info("Starting bot...")
+            application.run_polling()
+            
+        except Exception as e:
+            logger.error(f"Error running bot: {str(e)}")
+            raise
+
+if __name__ == "__main__":
+    # Get bot token from environment variable
+    BOT_TOKEN = os.getenv('TELEGRAM_BOT_TOKEN')
+    if not BOT_TOKEN:
+        raise ValueError("TELEGRAM_BOT_TOKEN not found in environment variables")
+    
+    bot = WeBookBot(BOT_TOKEN)
+    bot.run() 

utils.py

@@ -0,0 +1,57 @@
+import logging
+from playwright.sync_api import sync_playwright
+import os
+from pathlib import Path
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler('logs/webook_actions.log'),
+        logging.StreamHandler()
+    ]
+)
+
+logger = logging.getLogger(__name__)
+
+class WeBookBase:
+    def __init__(self, profile_dir=None, page=None):
+        self.profile_dir = profile_dir or os.path.join(Path.home(), '.webook_profile')
+        self.playwright = None
+        self.browser = None
+        self.page = page # Accept existing page
+        self.context = None # Keep track of context if created here
+
+    def _handle_cookies(self):
+        try:
+            cookie_banner = self.page.locator('#cookie_consent')
+            if cookie_banner.is_visible():
+                accept_button = self.page.get_by_role('button', name='Accept all')
+                if accept_button.is_visible():
+                    accept_button.click()
+                    logger.info("Cookie consent accepted")
+        except Exception as e:
+            logger.warning(f"Cookie handling issue: {str(e)}")
+
+    def _setup_browser(self):
+        if not self.page: # Only set up if page is not provided
+            self.playwright = sync_playwright().start()
+            self.context = self.playwright.chromium.launch_persistent_context(
+                user_data_dir=self.profile_dir,
+                headless=False,
+                args=[]
+            )
+            self.page = self.context.pages[0] if self.context.pages else self.context.new_page()
+            logger.info(f"Using profile directory: {self.profile_dir}")
+        # Return the page and context for external management
+        return self.context, self.page
+
+    # Removed the cleanup method
+    # def cleanup(self):
+    #     if hasattr(self, 'page') and self.page:
+    #         self.page.close()
+    #     if hasattr(self, 'browser') and self.browser:
+    #         self.browser.close()
+    #     if hasattr(self, 'playwright') and self.playwright:
+    #         self.playwright.stop()