Share local folder with container

- Fix 'id_user' key not found error by navigating the correct nested path
- Extract id_user from data.user.applications[0].users[0].id_user
- Add fallback to old structure for backward compatibility
- Prevents authentication failures due to API response format changes

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

.env.example

@@ -1,6 +1,9 @@
 # CrossFit booking credentials
 CROSSFIT_USERNAME=your_username
 CROSSFIT_PASSWORD=your_password
+TARGET_RESERVATION_TIME="21:01"
+BOOKING_WINDOW_END_DELTA_MINUTES="59"
+
 
 # Notification settings
 ENABLE_EMAIL_NOTIFICATIONS=true

.gitignore

@@ -1,4 +1,5 @@
 .env
+preferred_sessions.json
 log/
 !log/.gitkeep
 
@@ -177,4 +178,4 @@ poetry.toml
 # LSP config files
 pyrightconfig.json
 
-# End of https://www.toptal.com/developers/gitignore/api/python
+# End of https://www.toptal.com/developers/gitignore/api/python

AGENTS.md

@@ -0,0 +1,63 @@
+# Qwen Code Agent Configuration
+
+This file configures the behavior and preferences for the Qwen Code agent for this specific project.
+
+## Project Context
+- **Name**: CrossFit Scheduler
+- **Primary Language**: Python
+- **Key Technologies**: Python scripts, JSON, Docker
+- **Purpose**: Automates booking CrossFit classes based on user preferences.
+
+## Agent Interaction Preferences
+
+### Code Style & Conventions
+- Follow PEP 8 for Python code.
+- Use clear, descriptive variable and function names.
+- Prefer explicit over implicit code.
+- Use docstrings for modules, classes, and functions.
+- Keep functions small and focused on a single task.
+
+### Project Structure Awareness
+- `main.py`: Entry point for the application.
+- `execute_book_session.py`: Alternative execution script for booking sessions.
+- `preferred_sessions.json`: User preferences for session booking.
+- `src/`: Directory for source code modules.
+  - `auth.py`: Authentication handling with bearer token management.
+  - `booker.py`: Main booking logic with time-based booking windows.
+  - `session_manager.py`: Session fetching, filtering, and booking operations.
+  - `session_notifier.py`: Email and Telegram notifications for booking status.
+  - `session_config.py`: Configuration for preferred session matching.
+  - `test_book_session.sh`: Shell script for testing session booking.
+- `requirements.txt`: Python dependencies.
+- `Dockerfile` and `docker-compose.yml`: Container configuration.
+
+### Preferred Tools & Commands
+- Use `pytest` for running tests.
+- Use `docker compose` for container orchestration.
+- Use `python` for running scripts.
+- Refer to `requirements.txt` for dependencies.
+
+### Communication Style
+- Be concise and direct.
+- Use markdown for formatting responses.
+- Prioritize clarity and correctness.
+- Avoid unnecessary explanations or chit-chat.
+
+### Testing & Verification
+- Always run tests after making changes.
+- Use `pytest.ini` for test configuration.
+- Ensure Docker containers are properly configured before running.
+- Verify JSON files are correctly formatted.
+
+### Security & Best Practices
+- Never commit sensitive information like passwords or API keys.
+- Use `.env` files for environment variables.
+- Follow Docker best practices for containerization.
+- Keep dependencies up to date.
+
+## Custom Instructions
+- When modifying `preferred_sessions.json`, ensure the structure remains valid.
+- When writing shell scripts, ensure they are executable and follow best practices.
+- When creating new Python files, ensure they are properly formatted and tested.
+- Environment variables required: `CROSSFIT_USERNAME`, `CROSSFIT_PASSWORD`, plus optional email/telegram settings.
+- Booking window controlled by `TARGET_RESERVATION_TIME` (default: "20:01") and `BOOKING_WINDOW_END_DELTA_MINUTES` (default: 10).

Dockerfile

@@ -5,6 +5,8 @@ FROM python:3.11-slim
 WORKDIR /app
 
 # Set environment variables using the ARG values
+ENV TARGET_RESERVATION_TIME=${TARGET_RESERVATION_TIME}
+ENV BOOKING_WINDOW_END_DELTA_MINUTES=${BOOKING_WINDOW_END_DELTA_MINUTES}
 ENV CROSSFIT_USERNAME=${CROSSFIT_USERNAME}
 ENV CROSSFIT_PASSWORD=${CROSSFIT_PASSWORD}
 ENV EMAIL_FROM=${EMAIL_FROM}
@@ -26,4 +28,4 @@ COPY . .
 RUN mkdir -p log
 
 # Set the entry point to run the main script
-ENTRYPOINT ["python", "book_crossfit.py"]
+ENTRYPOINT ["python", "main.py"]

Dockerfile.test

@@ -1,17 +0,0 @@
-# Use the official Python image from the Docker Hub
-FROM python:3.11-slim
-
-# Set the working directory
-WORKDIR /app
-
-# Copy the requirements file into the container
-COPY requirements.txt .
-
-# Install the dependencies
-RUN pip install --no-cache-dir -r requirements.txt
-
-# Copy the rest of the application code
-COPY . .
-
-# Run the test script
-CMD ["python", "test_telegram_notifier.py"]

README.md

@@ -12,12 +12,16 @@ This is a Python application for managing Crossfit bookings and notifications. T
 
 ## Prerequisites
 
-- Docker
-- Docker Compose
+- Python 3.8+
+- Docker (optional)
+- Docker Compose (optional)
 
 ## Setup
 
 1. Create a `.env` file based on `.env.example` and fill in the required credentials.
+
+### Running with Docker (Recommended)
+
 2. Build and run the application using Docker Compose:
 
 ```bash
@@ -26,6 +30,20 @@ docker-compose up --build
 
 3. The application will run in a Docker container, and the logs will be stored in the `./log` directory.
 
+### Manual Setup
+
+2. Install dependencies:
+
+```bash
+pip install -r requirements.txt
+```
+
+3. Run the application:
+
+```bash
+python main.py
+```
+
 ## Usage
 
 The application will automatically check for available sessions and book them based on your preferences. It will send notifications via email and Telegram when a booking is successful.
@@ -76,32 +94,46 @@ The application will automatically load the preferred sessions from this file. I
 
 ## Files
 
+- `main.py`: Main entry point for the application
+- `src/`: Source code directory
+  - `auth.py`: Authentication handling
+  - `booker.py`: Main booking logic
+  - `session_manager.py`: Session management
+  - `session_notifier.py`: Notification handling
+  - `session_config.py`: Session configuration
+- `tools/`: Utility scripts
+- `scripts/`: Additional scripts
+- `test/`: Test files
 - `Dockerfile`: Docker image definition
 - `docker-compose.yml`: Docker Compose service definition
 - `.env.example`: Example environment variables file
 - `.dockerignore`: Docker ignore file
 - `.gitignore`: Git ignore file
-- `book_crossfit.py`: Main application script
-- `crossfit_booker.py`: Crossfit booking script
-- `session_notifier.py`: Session notification script
-- `preferred_sessions.json`: Configuration file for preferred sessions
+- `preferred_sessions.json.example`: Example configuration file for preferred sessions
 - `requirements.txt`: Python dependencies
 
 ## Project Structure
 
 ```
 .
+├── main.py
+├── src/
+│   ├── auth.py
+│   ├── booker.py
+│   ├── session_manager.py
+│   ├── session_notifier.py
+│   └── session_config.py
+├── tools/
+├── scripts/
+├── test/
 ├── Dockerfile
 ├── docker-compose.yml
 ├── .env.example
 ├── .dockerignore
 ├── .gitignore
-├── book_crossfit.py
-├── crossfit_booker.py
-├── session_notifier.py
+├── preferred_sessions.json.example
 ├── requirements.txt
-├── preferred_sessions.json
-└── log
+└── log/
     └── crossfit_booking.log
 ```
 

TODO

@@ -1,36 +0,0 @@
-Missing or Inadequate Test Coverage
-1. SessionConfig Class (session_config.py)
-Missing Tests:
-
-load_preferred_sessions method has no dedicated unit tests
-No tests for file not found scenario
-No tests for JSON decode error scenario
-No tests for empty or invalid configuration files
-2. SessionNotifier Class (session_notifier.py)
-Missing Tests:
-
-__init__ method
-send_email_notification method
-send_telegram_notification method
-notify_session_booking method
-notify_upcoming_session method
-notify_impossible_booking method
-3. CrossFitBooker Class (crossfit_booker_functional.py) - Missing Tests
-get_auth_headers function (functional version)
-prepare_booking_data function
-is_bookable_and_preferred function
-process_booking_results function
-is_upcoming_preferred function
-4. CrossFitBooker Class (crossfit_booker.py) - Missing Tests
-is_session_bookable method (non-functional version)
-_make_request method
-5. Integration and Edge Cases
-No tests for the main entry point (book_crossfit.py)
-Limited testing of error conditions and edge cases for many methods
-No performance or stress tests
-No tests for concurrent booking scenarios
-
-
-
-Add integration tests for the complete booking flow
-Improve edge case coverage in existing tests

ascii.md

@@ -0,0 +1,9 @@
+                                                        
+   ▄▄▄                              ▄▄▄▄▄▄   ▀          
+ ▄▀   ▀  ▄ ▄▄   ▄▄▄    ▄▄▄    ▄▄▄   █      ▄▄▄    ▄   ▄ 
+ █       █▀  ▀ █▀ ▀█  █   ▀  █   ▀  █▄▄▄▄▄   █     █▄█  
+ █       █     █   █   ▀▀▀▄   ▀▀▀▄  █        █     ▄█▄  
+  ▀▄▄▄▀  █     ▀█▄█▀  ▀▄▄▄▀  ▀▄▄▄▀  █      ▄▄█▄▄  ▄▀ ▀▄ 
+                                                        
+                                                        
+

book_crossfit.py

@@ -1,35 +0,0 @@
-#!/usr/bin/env python3
-
-import logging
-import traceback
-import asyncio
-from crossfit_booker import CrossFitBooker
-
-if __name__ == "__main__":
-    # Configure logging once at script startup
-    logging.basicConfig(
-        level=logging.DEBUG,  # Change to DEBUG for more detailed logs
-        format='%(asctime)s - %(levelname)s - %(message)s',
-        handlers=[
-            logging.FileHandler("log/crossfit_booking.log"),
-            logging.StreamHandler()
-        ]
-    )
-
-    # Reduce the verbosity of the requests library's logging
-    logging.getLogger("requests").setLevel(logging.WARNING)
-    logging.info("Logging enhanced with request library noise reduction")
-
-    # Create an instance of the CrossFitBooker class
-    booker = CrossFitBooker()
-
-    # Attempt to log in to the CrossFit booking system
-    # TODO: Make a authentication during running request to not get kicked out
-    if not booker.login():
-        # If login fails, log the error and exit the script
-        logging.error("Failed to login - Traceback: %s", traceback.format_exc())
-        exit(1)
-
-    # Start the continuous booking loop
-    asyncio.run(booker.run())
-    logging.info("Script completed")

crossfit_booker.py

@@ -1,484 +0,0 @@
-# Native modules
-import logging
-import traceback
-import os
-import time
-import difflib
-from datetime import datetime, timedelta, date
-
-# Third-party modules
-import requests
-from dateutil.parser import parse
-import pytz
-from dotenv import load_dotenv
-from urllib.parse import urlencode
-from typing import List, Dict, Optional, Any, Tuple
-
-# Import the SessionNotifier class
-from session_notifier import SessionNotifier
-
-# Import the preferred sessions from the session_config module
-from session_config import PREFERRED_SESSIONS
-
-load_dotenv()
-
-# Configuration
-USERNAME = os.environ.get("CROSSFIT_USERNAME")
-PASSWORD = os.environ.get("CROSSFIT_PASSWORD")
-
-if not all([USERNAME, PASSWORD]):
-    raise ValueError("Missing environment variables: CROSSFIT_USERNAME and/or CROSSFIT_PASSWORD")
-
-APPLICATION_ID = "81560887"
-CATEGORY_ID = "677"  # Activity category ID for CrossFit
-TIMEZONE = "Europe/Paris"  # Adjust to your timezone
-TARGET_RESERVATION_TIME = "20:01"  # When bookings open (8 PM)
-BOOKING_WINDOW_END_DELTA_MINUTES = 50 # End window book session
-DEVICE_TYPE = "3"
-
-# Retry configuration
-RETRY_MAX = 3
-RETRY_BACKOFF = 1
-APP_VERSION = "5.09.21"
-
-
-class CrossFitBooker:
-    """
-    A class for automating the booking of CrossFit sessions.
-    This class handles authentication, session availability checking,
-    booking, and notifications for CrossFit sessions.
-    """
-
-    def __init__(self) -> None:
-        """
-        Initialize the CrossFitBooker with necessary attributes.
-        Sets up authentication tokens, session headers, mandatory parameters,
-        and initializes the SessionNotifier for sending notifications.
-        """
-        self.auth_token: Optional[str] = None
-        self.user_id: Optional[str] = None
-        self.session: requests.Session = requests.Session()
-        self.base_headers: Dict[str, str] = {
-            "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:140.0) Gecko/20100101 Firefox/140.0",
-            "Content-Type": "application/x-www-form-urlencoded",
-            "Nubapp-Origin": "user_apps",
-        }
-        self.session.headers.update(self.base_headers)
-
-        # Define mandatory parameters for API calls
-        self.mandatory_params: Dict[str, str] = {
-            "app_version": APP_VERSION,
-            "device_type": DEVICE_TYPE,
-            "id_application": APPLICATION_ID,
-            "id_category_activity": CATEGORY_ID
-        }
-
-        # Initialize the SessionNotifier with credentials from environment variables
-        email_credentials = {
-            "from": os.environ.get("EMAIL_FROM"),
-            "to": os.environ.get("EMAIL_TO"),
-            "password": os.environ.get("EMAIL_PASSWORD")
-        }
-
-        telegram_credentials = {
-            "token": os.environ.get("TELEGRAM_TOKEN"),
-            "chat_id": os.environ.get("TELEGRAM_CHAT_ID")
-        }
-
-        # Get notification settings from environment variables
-        enable_email = os.environ.get("ENABLE_EMAIL_NOTIFICATIONS", "true").lower() in ("true", "1", "yes")
-        enable_telegram = os.environ.get("ENABLE_TELEGRAM_NOTIFICATIONS", "true").lower() in ("true", "1", "yes")
-
-        self.notifier = SessionNotifier(
-            email_credentials,
-            telegram_credentials,
-            enable_email=enable_email,
-            enable_telegram=enable_telegram
-        )
-
-    def get_auth_headers(self) -> Dict[str, str]:
-        """
-        Return headers with authorization if available.
-        Returns:
-            Dict[str, str]: Headers dictionary with authorization if available.
-        """
-        headers: Dict[str, str] = self.base_headers.copy()
-        if self.auth_token:
-            headers["Authorization"] = f"Bearer {self.auth_token}"
-        return headers
-
-    def login(self) -> bool:
-        """
-        Authenticate and get the bearer token.
-        Returns:
-            bool: True if login is successful, False otherwise.
-        """
-        try:
-            # First login endpoint
-            login_params: Dict[str, str] = {
-                "app_version": APP_VERSION,
-                "device_type": DEVICE_TYPE,
-                "username": USERNAME,
-                "password": PASSWORD
-            }
-
-            response: requests.Response = self.session.post(
-                "https://sport.nubapp.com/api/v4/users/checkUser.php",
-                headers={"Content-Type": "application/x-www-form-urlencoded"},
-                data=urlencode(login_params))
-
-            if not response.ok:
-                logging.error(f"First login step failed: {response.status_code} - {response.text[:100]}")
-                return False
-
-            try:
-                login_data: Dict[str, Any] = response.json()
-                self.user_id = str(login_data["data"]["user"]["id_user"])
-            except (KeyError, ValueError) as e:
-                logging.error(f"Error during login: {str(e)} - Response: {response.text}")
-                return False
-
-            # Second login endpoint
-            response: requests.Response = self.session.post(
-                "https://sport.nubapp.com/api/v4/login",
-                headers={"Content-Type": "application/x-www-form-urlencoded;charset=UTF-8"},
-                data=urlencode({
-                    "device_type": DEVICE_TYPE,
-                    "username": USERNAME,
-                    "password": PASSWORD
-                }))
-
-            if response.ok:
-                try:
-                    login_data: Dict[str, Any] = response.json()
-                    self.auth_token = login_data.get("token")
-                except (KeyError, ValueError) as e:
-                    logging.error(f"Error during login: {str(e)} - Response: {response.text}")
-                    return False
-
-                if self.auth_token and self.user_id:
-                    logging.info("Successfully logged in")
-                    return True
-            else:
-                logging.error(f"Login failed: {response.status_code} - {response.text[:100]}")
-                return False
-
-        except requests.exceptions.RequestException as e:
-            logging.error(f"Request error during login: {str(e)}")
-            return False
-        except Exception as e:
-            logging.error(f"Unexpected error during login: {str(e)}")
-            return False
-
-    def get_available_sessions(self, start_date: date, end_date: date) -> Optional[Dict[str, Any]]:
-        """
-        Fetch available sessions from the API.
-        Args:
-            start_date (date): Start date for fetching sessions.
-            end_date (date): End date for fetching sessions.
-        Returns:
-            Optional[Dict[str, Any]]: Dictionary containing available sessions if successful, None otherwise.
-        """
-        if not self.auth_token or not self.user_id:
-            logging.error("Authentication required - missing token or user ID")
-            return None
-
-        url: str = "https://sport.nubapp.com/api/v4/activities/getActivitiesCalendar.php"
-
-        # Prepare request with mandatory parameters
-        request_data: Dict[str, str] = self.mandatory_params.copy()
-        request_data.update({
-            "id_user": self.user_id,
-            "start_timestamp": start_date.strftime("%d-%m-%Y"),
-            "end_timestamp": end_date.strftime("%d-%m-%Y")
-        })
-
-        # Add retry logic
-        for retry in range(RETRY_MAX):
-            try:
-                response: requests.Response = self.session.post(
-                    url,
-                    headers=self.get_auth_headers(),
-                    data=urlencode(request_data),
-                    timeout=10
-                )
-                
-                if response.status_code == 200:
-                    return response.json()
-                elif response.status_code == 401:
-                    logging.error("401 Unauthorized - token may be expired or invalid")
-                    return None
-                elif 500 <= response.status_code < 600:
-                    logging.error(f"Server error {response.status_code}")
-                    raise requests.exceptions.ConnectionError(f"Server error {response.status_code}")
-                else:
-                    logging.error(f"Unexpected status code: {response.status_code} - {response.text[:100]}")
-                    return None
-                    
-            except requests.exceptions.RequestException as e:
-                if retry == RETRY_MAX - 1:
-                    logging.error(f"Final retry failed: {str(e)}")
-                    raise
-                wait_time: int = RETRY_BACKOFF * (2 ** retry)
-                logging.warning(f"Request failed (attempt {retry+1}/{RETRY_MAX}): {str(e)}. Retrying in {wait_time}s...")
-                time.sleep(wait_time)
-
-        return None
-
-    def book_session(self, session_id: str) -> bool:
-        """
-        Book a specific session.
-        Args:
-            session_id (str): ID of the session to book.
-        Returns:
-            bool: True if booking is successful, False otherwise.
-        """
-        url = "https://sport.nubapp.com/api/v4/activities/bookActivityCalendar.php"
-        data = {
-            **self.mandatory_params,
-            "id_activity_calendar": session_id,
-            "id_user": self.user_id,
-            "action_by": self.user_id,
-            "n_guests": "0",
-            "booked_on": "3"
-        }
-        
-        for retry in range(RETRY_MAX):
-            try:
-                response: requests.Response = self.session.post(
-                    url,
-                    headers=self.get_auth_headers(),
-                    data=urlencode(data),
-                    timeout=10
-                )
-
-                if response.status_code == 200:
-                    json_response: Dict[str, Any] = response.json()
-                    if json_response.get("success", False):
-                        logging.info(f"Successfully booked session {session_id}")
-                        return True
-                    logging.error(f"API returned success:false: {json_response}")
-                    return False
-
-                logging.error(f"HTTP {response.status_code}: {response.text[:100]}")
-                return False
-
-            except requests.exceptions.RequestException as e:
-                if retry == RETRY_MAX - 1:
-                    logging.error(f"Final retry failed: {str(e)}")
-                    raise
-                wait_time: int = RETRY_BACKOFF * (2 ** retry)
-                logging.warning(f"Request failed (attempt {retry+1}/{RETRY_MAX}): {str(e)}. Retrying in {wait_time}s...")
-                time.sleep(wait_time)
-
-        logging.error(f"Failed to complete request after {RETRY_MAX} attempts")
-        return False
-
-    def is_session_bookable(self, session: Dict[str, Any], current_time: datetime) -> bool:
-        """
-        Check if a session is bookable based on user_info.
-        Args:
-            session (Dict[str, Any]): Session data.
-            current_time (datetime): Current time for comparison.
-        Returns:
-            bool: True if the session is bookable, False otherwise.
-        """
-        user_info: Dict[str, Any] = session.get("user_info", {})
-
-        # First check if can_join is true (primary condition)
-        if user_info.get("can_join", False):
-            return True
-
-        # If can_join is False, check if there's a booking window
-        booking_date_str: str = user_info.get("unableToBookUntilDate", "")
-        booking_time_str: str = user_info.get("unableToBookUntilTime", "")
-
-        if booking_date_str and booking_time_str:
-            try:
-                booking_datetime: datetime = datetime.strptime(
-                    f"{booking_date_str} {booking_time_str}",
-                    "%d-%m-%Y %H:%M"
-                )
-                booking_datetime = pytz.timezone(TIMEZONE).localize(booking_datetime)
-
-                if current_time >= booking_datetime:
-                    return True  # Booking window is open
-            except ValueError:
-                pass  # Ignore invalid date formats
-
-        # Default case: not bookable
-        return False
-
-    def matches_preferred_session(self, session: Dict[str, Any], current_time: datetime) -> bool:
-        """
-        Check if session matches one of your preferred sessions with fuzzy matching.
-        Args:
-            session (Dict[str, Any]): Session data.
-            current_time (datetime): Current time for comparison.
-        Returns:
-            bool: True if the session matches a preferred session, False otherwise.
-        """
-        try:
-            session_time: datetime = parse(session["start_timestamp"])
-            if not session_time.tzinfo:
-                session_time = pytz.timezone(TIMEZONE).localize(session_time)
-
-            day_of_week: int = session_time.weekday()
-            session_time_str: str = session_time.strftime("%H:%M")
-            session_name: str = session.get("name_activity", "").upper()
-
-            for preferred_day, preferred_time, preferred_name in PREFERRED_SESSIONS:
-                # Exact match first
-                if (day_of_week == preferred_day and
-                    session_time_str == preferred_time and
-                    preferred_name in session_name):
-                    return True
-
-                # Fuzzy match fallback (80% similarity)
-                ratio: float = difflib.SequenceMatcher(
-                    None,
-                    session_name.lower(),
-                    preferred_name.lower()
-                ).ratio()
-
-                if (day_of_week == preferred_day and
-                    abs(session_time.hour - int(preferred_time.split(':')[0])) <= 1 and
-                    ratio >= 0.8):
-                    logging.debug(f"Fuzzy match: {session_name} → {preferred_name} ({ratio:.2%})")
-                    return True
-
-            return False
-
-        except Exception as e:
-            logging.error(f"Failed to check session: {str(e)} - Session: {session}")
-            return False
-
-    async def run_booking_cycle(self, current_time: datetime) -> None:
-        """
-        Run one cycle of checking and booking sessions.
-        Args:
-            current_time (datetime): Current time for comparison.
-        """
-        # Calculate date range to check (current day, day + 1, and day + 2)
-        start_date: date = current_time.date()
-        end_date: date = start_date + timedelta(days=2)  # Only go up to day + 2
-
-        # Get available sessions
-        sessions_data: Optional[Dict[str, Any]] = self.get_available_sessions(start_date, end_date)
-        if not sessions_data or not sessions_data.get("success", False):
-            logging.error("No sessions available or error fetching sessions")
-            return
-
-        activities: List[Dict[str, Any]] = sessions_data.get("data", {}).get("activities_calendar", [])
-
-        # Find sessions to book (preferred only) within allowed date range
-        sessions_to_book: List[Tuple[str, Dict[str, Any]]] = []
-        upcoming_sessions: List[Dict[str, Any]] = []
-        found_preferred_sessions: List[Dict[str, Any]] = []
-
-        for session in activities:
-            session_time: datetime = parse(session["start_timestamp"])
-            if not session_time.tzinfo:
-                session_time = pytz.timezone(TIMEZONE).localize(session_time)
-
-            # Check if session is within allowed date range (current day, day + 1, or day + 2)
-            days_diff = (session_time.date() - current_time.date()).days
-            if not (0 <= days_diff <= 2):
-                continue  # Skip sessions outside the allowed date range
-
-            # Check if session is preferred and bookable
-            if self.is_session_bookable(session, current_time):
-                if self.matches_preferred_session(session, current_time):
-                    sessions_to_book.append(("Preferred", session))
-                    found_preferred_sessions.append(session)
-            else:
-                # Check if it's a preferred session that's not bookable yet
-                if self.matches_preferred_session(session, current_time):
-                    found_preferred_sessions.append(session)
-                    # Check if it's available tomorrow (day + 1)
-                    if days_diff == 1:
-                        upcoming_sessions.append(session)
-
-        if not sessions_to_book and not upcoming_sessions:
-            logging.info("No matching sessions found to book")
-            return
-
-        # Notify about all found preferred sessions, regardless of bookability
-        for session in found_preferred_sessions:
-            session_time: datetime = parse(session["start_timestamp"])
-            if not session_time.tzinfo:
-                session_time = pytz.timezone(TIMEZONE).localize(session_time)
-            session_details = f"{session['id_activity_calendar']} {session['name_activity']} at {session_time.strftime('%Y-%m-%d %H:%M')}"
-            await self.notifier.notify_session_booking(session_details)
-            logging.info(f"Notified about found preferred session: {session_details}")
-
-        # Notify about upcoming sessions
-        for session in upcoming_sessions:
-            session_time: datetime = parse(session["start_timestamp"])
-            if not session_time.tzinfo:
-                session_time = pytz.timezone(TIMEZONE).localize(session_time)
-            session_details = f"{session['id_activity_calendar']} {session['name_activity']} at {session_time.strftime('%Y-%m-%d %H:%M')}"
-            await self.notifier.notify_upcoming_session(session_details, 1)  # Days until is 1 for tomorrow
-            logging.info(f"Notified about upcoming session: {session_details}")
-
-        # Book sessions (preferred first)
-        sessions_to_book.sort(key=lambda x: 0 if x[0] == "Preferred" else 1)
-        for session_type, session in sessions_to_book:
-            session_time: datetime = datetime.strptime(session["start_timestamp"], "%Y-%m-%d %H:%M:%S")
-            logging.info(f"Attempting to book {session_type} session at {session_time} ({session['name_activity']})")
-            if self.book_session(session["id_activity_calendar"]):
-                # Send notification after successful booking
-                session_details = f"{session['name_activity']} at {session_time.strftime('%Y-%m-%d %H:%M')}"
-                await self.notifier.notify_session_booking(session_details)
-                logging.info(f"Successfully booked {session_type} session at {session_time}")
-            else:
-                logging.error(f"Failed to book {session_type} session at {session_time}")
-                # Send notification about the failed booking
-                session_details = f"{session['name_activity']} at {session_time.strftime('%Y-%m-%d %H:%M')}"
-                await self.notifier.notify_impossible_booking(session_details)
-                logging.info(f"Notified about impossible booking for {session_type} session at {session_time}")
-
-    async def run(self) -> None:
-        """
-        Main execution loop.
-        """
-        # Set up timezone
-        tz: pytz.timezone = pytz.timezone(TIMEZONE)
-
-        # Parse TARGET_RESERVATION_TIME to get the target hour and minute
-        target_hour, target_minute = map(int, TARGET_RESERVATION_TIME.split(":"))
-        target_time = datetime.now(tz).replace(hour=target_hour, minute=target_minute, second=0, microsecond=0)
-        booking_window_end = target_time + timedelta(minutes=BOOKING_WINDOW_END_DELTA_MINUTES)
-
-        # Initial login
-        if not self.login():
-            logging.error("Authentication failed - exiting program")
-            return
-
-        try:
-            while True:
-                try:
-                    current_time: datetime = datetime.now(tz)
-                    logging.info(f"Current time: {current_time}")
-
-                    # Only book sessions if current time is within the booking window
-                    if target_time <= current_time <= booking_window_end:
-                        # Run booking cycle to check for preferred sessions and book
-                        await self.run_booking_cycle(current_time)
-                        # Wait for a short time before next check
-                        time.sleep(60)
-                    else:
-                        # Check again in 5 minutes if outside booking window
-                        time.sleep(300)
-                except Exception as e:
-                    logging.error(f"Unexpected error in booking cycle: {str(e)} - Traceback: {traceback.format_exc()}")
-                    time.sleep(60)  # Wait before retrying after error
-        except KeyboardInterrupt:
-            self.quit()
-
-    def quit(self) -> None:
-        """
-        Clean up resources and exit the script.
-        """
-        logging.info("Script interrupted by user. Quitting...")
-        exit(0)

crossfit_booker_functional.py

@@ -1,729 +0,0 @@
-# Native modules
-import logging
-import traceback
-import os
-import time
-import difflib
-from datetime import datetime, timedelta, date
-from typing import List, Dict, Optional, Any, Tuple
-from functools import reduce
-
-# Third-party modules
-import requests
-from dateutil.parser import parse
-import pytz
-from dotenv import load_dotenv
-from urllib.parse import urlencode
-
-# Import the SessionNotifier class
-from session_notifier import SessionNotifier
-
-# Import the preferred sessions from the session_config module
-from session_config import PREFERRED_SESSIONS
-
-load_dotenv()
-
-# Configuration
-USERNAME = os.environ.get("CROSSFIT_USERNAME")
-PASSWORD = os.environ.get("CROSSFIT_PASSWORD")
-
-if not all([USERNAME, PASSWORD]):
-    raise ValueError("Missing environment variables: CROSSFIT_USERNAME and/or CROSSFIT_PASSWORD")
-
-APPLICATION_ID = "81560887"
-CATEGORY_ID = "677"  # Activity category ID for CrossFit
-TIMEZONE = "Europe/Paris"  # Adjust to your timezone
-TARGET_RESERVATION_TIME = "20:01"  # When bookings open (8 PM)
-DEVICE_TYPE = "3"  # Crossfit Louvre 3
-
-# Retry configuration
-RETRY_MAX = 3
-RETRY_BACKOFF = 1
-APP_VERSION = "5.09.21"
-
-
-# Pure functions for data processing
-def get_auth_headers(base_headers: Dict[str, str], auth_token: Optional[str]) -> Dict[str, str]:
-    """
-    Return headers with authorization if available.
-    
-    Args:
-        base_headers (Dict[str, str]): Base headers dictionary
-        auth_token (Optional[str]): Authorization token if available
-        
-    Returns:
-        Dict[str, str]: Headers dictionary with authorization if available.
-    """
-    headers: Dict[str, str] = base_headers.copy()
-    if auth_token:
-        headers["Authorization"] = f"Bearer {auth_token}"
-    return headers
-
-
-def is_session_bookable(session: Dict[str, Any], current_time: datetime, timezone: str) -> bool:
-    """
-    Check if a session is bookable based on user_info, ignoring error codes.
-    
-    Args:
-        session (Dict[str, Any]): Session data.
-        current_time (datetime): Current time for comparison.
-        timezone (str): Timezone string for localization.
-        
-    Returns:
-        bool: True if the session is bookable, False otherwise.
-    """
-    user_info: Dict[str, Any] = session.get("user_info", {})
-
-    # First check if can_join is true (primary condition)
-    if user_info.get("can_join", False):
-        return True
-
-    # If can_join is False, check if there's a booking window
-    booking_date_str: str = user_info.get("unableToBookUntilDate", "")
-    booking_time_str: str = user_info.get("unableToBookUntilTime", "")
-
-    if booking_date_str and booking_time_str:
-        try:
-            booking_datetime: datetime = datetime.strptime(
-                f"{booking_date_str} {booking_time_str}",
-                "%d-%m-%Y %H:%M"
-            )
-            booking_datetime = pytz.timezone(timezone).localize(booking_datetime)
-
-            if current_time >= booking_datetime:
-                return True  # Booking window is open
-            else:
-                return False  # Still waiting for booking to open
-        except ValueError:
-            pass  # Ignore invalid date formats
-
-    # Default case: not bookable
-    return False
-
-
-def matches_preferred_session(session: Dict[str, Any], preferred_sessions: List[Tuple[int, str, str]], 
-                             timezone: str) -> bool:
-    """
-    Check if session matches one of your preferred sessions with fuzzy matching.
-    
-    Args:
-        session (Dict[str, Any]): Session data.
-        preferred_sessions (List[Tuple[int, str, str]]): List of preferred sessions.
-        timezone (str): Timezone string for localization.
-        
-    Returns:
-        bool: True if the session matches a preferred session, False otherwise.
-    """
-    try:
-        session_time: datetime = parse(session["start_timestamp"])
-        if not session_time.tzinfo:
-            session_time = pytz.timezone(timezone).localize(session_time)
-
-        day_of_week: int = session_time.weekday()
-        session_time_str: str = session_time.strftime("%H:%M")
-        session_name: str = session.get("name_activity", "").upper()
-
-        for preferred_day, preferred_time, preferred_name in preferred_sessions:
-            # Exact match first
-            if (day_of_week == preferred_day and
-                session_time_str == preferred_time and
-                preferred_name in session_name):
-                return True
-
-            # Fuzzy match fallback (80% similarity)
-            ratio: float = difflib.SequenceMatcher(
-                None,
-                session_name.lower(),
-                preferred_name.lower()
-            ).ratio()
-
-            if (day_of_week == preferred_day and
-                abs(session_time.hour - int(preferred_time.split(':')[0])) <= 1 and
-                ratio >= 0.8):
-                logging.debug(f"Fuzzy match: {session_name} → {preferred_name} ({ratio:.2%})")
-                return True
-
-        return False
-
-    except Exception as e:
-        logging.error(f"Failed to check session: {str(e)} - Session: {session}")
-        return False
-
-
-def prepare_booking_data(mandatory_params: Dict[str, str], session_id: str, user_id: str) -> Dict[str, str]:
-    """
-    Prepare request data for booking a session.
-    
-    Args:
-        mandatory_params (Dict[str, str]): Mandatory parameters for API calls
-        session_id (str): ID of the session to book
-        user_id (str): User ID for the booking
-        
-    Returns:
-        Dict[str, str]: Dictionary containing request data for booking a session.
-    """
-    return {
-        **mandatory_params,
-        "id_activity_calendar": session_id,
-        "id_user": user_id,
-        "action_by": user_id,
-        "n_guests": "0",
-        "booked_on": "3"  # Target CrossFit Louvre 3 ?
-    }
-
-
-def is_bookable_and_preferred(session: Dict[str, Any], current_time: datetime, 
-                             preferred_sessions: List[Tuple[int, str, str]], timezone: str) -> bool:
-    """
-    Check if a session is both bookable and matches preferred sessions.
-    
-    Args:
-        session (Dict[str, Any]): Session data
-        current_time (datetime): Current time for comparison
-        preferred_sessions (List[Tuple[int, str, str]]): List of preferred sessions
-        timezone (str): Timezone string for localization
-        
-    Returns:
-        bool: True if session is bookable and preferred, False otherwise
-    """
-    return (is_session_bookable(session, current_time, timezone) and 
-            matches_preferred_session(session, preferred_sessions, timezone))
-
-
-def filter_bookable_sessions(sessions: List[Dict[str, Any]], current_time: datetime, 
-                           preferred_sessions: List[Tuple[int, str, str]], timezone: str) -> List[Dict[str, Any]]:
-    """
-    Filter sessions to find those that are both bookable and match preferred sessions.
-    
-    Args:
-        sessions (List[Dict[str, Any]]): List of session data
-        current_time (datetime): Current time for comparison
-        preferred_sessions (List[Tuple[int, str, str]]): List of preferred sessions
-        timezone (str): Timezone string for localization
-        
-    Returns:
-        List[Dict[str, Any]]: List of sessions that are bookable and match preferences
-    """
-    return list(filter(
-        lambda session: is_bookable_and_preferred(session, current_time, preferred_sessions, timezone),
-        sessions
-    ))
-
-
-def is_upcoming_preferred(session: Dict[str, Any], current_time: datetime,
-                          preferred_sessions: List[Tuple[int, str, str]], timezone: str) -> bool:
-    """
-    Check if a session is an upcoming preferred session.
-
-    Args:
-        session (Dict[str, Any]): Session data
-        current_time (datetime): Current time for comparison
-        preferred_sessions (List[Tuple[int, str, str]]): List of preferred sessions
-        timezone (str): Timezone string for localization
-
-    Returns:
-        bool: True if session is an upcoming preferred session, False otherwise
-    """
-    try:
-        session_time: datetime = parse(session["start_timestamp"])
-        if not session_time.tzinfo:
-            session_time = pytz.timezone(timezone).localize(session_time)
-
-        # Calculate the difference in days between session date and current date
-        days_diff = (session_time.date() - current_time.date()).days
-
-        # Check if session is within allowed date range (current day, day + 1, or day + 2)
-        is_in_range = 0 <= days_diff <= 2
-
-        # Check if it's a preferred session
-        is_preferred = matches_preferred_session(session, preferred_sessions, timezone)
-
-        # Only consider sessions that are tomorrow or later as upcoming
-        is_upcoming = days_diff > 0
-
-        # For the test case, we only need to check if it's tomorrow
-        if days_diff == 1:
-            return True
-
-        return is_in_range and is_preferred and is_upcoming
-    except Exception:
-        return False
-
-
-def filter_upcoming_sessions(sessions: List[Dict[str, Any]], current_time: datetime,
-                           preferred_sessions: List[Tuple[int, str, str]], timezone: str) -> List[Dict[str, Any]]:
-    """
-    Filter sessions to find upcoming preferred sessions.
-    
-    Args:
-        sessions (List[Dict[str, Any]]): List of session data
-        current_time (datetime): Current time for comparison
-        preferred_sessions (List[Tuple[int, str, str]]): List of preferred sessions
-        timezone (str): Timezone string for localization
-        
-    Returns:
-        List[Dict[str, Any]]: List of upcoming preferred sessions
-    """
-    return list(filter(
-        lambda session: is_upcoming_preferred(session, current_time, preferred_sessions, timezone),
-        sessions
-    ))
-
-
-def filter_preferred_sessions(sessions: List[Dict[str, Any]], 
-                             preferred_sessions: List[Tuple[int, str, str]], 
-                             timezone: str) -> List[Dict[str, Any]]:
-    """
-    Filter sessions to find all preferred sessions.
-    
-    Args:
-        sessions (List[Dict[str, Any]]): List of session data
-        preferred_sessions (List[Tuple[int, str, str]]): List of preferred sessions
-        timezone (str): Timezone string for localization
-        
-    Returns:
-        List[Dict[str, Any]]: List of preferred sessions
-    """
-    return list(filter(
-        lambda session: matches_preferred_session(session, preferred_sessions, timezone),
-        sessions
-    ))
-
-
-def format_session_details(session: Dict[str, Any], timezone: str) -> str:
-    """
-    Format session details for notifications.
-    
-    Args:
-        session (Dict[str, Any]): Session data
-        timezone (str): Timezone string for localization
-        
-    Returns:
-        str: Formatted session details
-    """
-    try:
-        session_time: datetime = parse(session["start_timestamp"])
-        if not session_time.tzinfo:
-            session_time = pytz.timezone(timezone).localize(session_time)
-        return f"{session['name_activity']} at {session_time.strftime('%Y-%m-%d %H:%M')}"
-    except Exception:
-        return f"{session.get('name_activity', 'Unknown session')} at Unknown time"
-
-
-def categorize_sessions(activities: List[Dict[str, Any]], current_time: datetime,
-                       preferred_sessions: List[Tuple[int, str, str]], timezone: str) -> Dict[str, List[Dict[str, Any]]]:
-    """
-    Categorize sessions into bookable, upcoming, and all preferred sessions.
-    
-    Args:
-        activities (List[Dict[str, Any]]): List of session data
-        current_time (datetime): Current time for comparison
-        preferred_sessions (List[Tuple[int, str, str]]): List of preferred sessions
-        timezone (str): Timezone string for localization
-        
-    Returns:
-        Dict[str, List[Dict[str, Any]]]: Dictionary with categorized sessions
-    """
-    return {
-        "bookable": filter_bookable_sessions(activities, current_time, preferred_sessions, timezone),
-        "upcoming": filter_upcoming_sessions(activities, current_time, preferred_sessions, timezone),
-        "all_preferred": filter_preferred_sessions(activities, preferred_sessions, timezone)
-    }
-
-
-def process_booking_results(session: Dict[str, Any], booking_success: bool, timezone: str) -> Dict[str, Any]:
-    """
-    Process the results of a booking attempt.
-    
-    Args:
-        session (Dict[str, Any]): Session data
-        booking_success (bool): Whether the booking was successful
-        timezone (str): Timezone string for localization
-        
-    Returns:
-        Dict[str, Any]: Dictionary with session and booking result information
-    """
-    return {
-        "session": session,
-        "success": booking_success,
-        "details": format_session_details(session, timezone)
-    }
-
-
-class CrossFitBooker:
-    """
-    A class for automating the booking of CrossFit sessions.
-    
-    This class handles authentication, session availability checking,
-    booking, and notifications for CrossFit sessions.
-    """
-
-    def __init__(self) -> None:
-        """
-        Initialize the CrossFitBooker with necessary attributes.
-        
-        Sets up authentication tokens, session headers, mandatory parameters,
-        and initializes the SessionNotifier for sending notifications.
-        """
-        self.auth_token: Optional[str] = None
-        self.user_id: Optional[str] = None
-        self.session: requests.Session = requests.Session()
-        self.base_headers: Dict[str, str] = {
-            "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:140.0) Gecko/20100101 Firefox/140.0",
-            "Content-Type": "application/x-www-form-urlencoded",
-            "Nubapp-Origin": "user_apps",
-        }
-        self.session.headers.update(self.base_headers)
-
-        # Define mandatory parameters for API calls
-        self.mandatory_params: Dict[str, str] = {
-            "app_version": APP_VERSION,
-            "device_type": DEVICE_TYPE,
-            "id_application": APPLICATION_ID,
-            "id_category_activity": CATEGORY_ID
-        }
-
-        # Initialize the SessionNotifier with credentials from environment variables
-        email_credentials = {
-            "from": os.environ.get("EMAIL_FROM"),
-            "to": os.environ.get("EMAIL_TO"),
-            "password": os.environ.get("EMAIL_PASSWORD")
-        }
-
-        telegram_credentials = {
-            "token": os.environ.get("TELEGRAM_TOKEN"),
-            "chat_id": os.environ.get("TELEGRAM_CHAT_ID")
-        }
-
-        # Get notification settings from environment variables
-        enable_email = os.environ.get("ENABLE_EMAIL_NOTIFICATIONS", "true").lower() in ("true", "1", "yes")
-        enable_telegram = os.environ.get("ENABLE_TELEGRAM_NOTIFICATIONS", "true").lower() in ("true", "1", "yes")
-
-        self.notifier = SessionNotifier(
-            email_credentials,
-            telegram_credentials,
-            enable_email=enable_email,
-            enable_telegram=enable_telegram
-        )
-
-    def login(self) -> bool:
-        """
-        Authenticate and get the bearer token.
-        
-        Returns:
-            bool: True if login is successful, False otherwise.
-        """
-        try:
-            # First login endpoint
-            login_params: Dict[str, str] = {
-                "app_version": APP_VERSION,
-                "device_type": DEVICE_TYPE,
-                "username": USERNAME,
-                "password": PASSWORD
-            }
-
-            response: requests.Response = self.session.post(
-                "https://sport.nubapp.com/api/v4/users/checkUser.php",
-                headers={"Content-Type": "application/x-www-form-urlencoded"},
-                data=urlencode(login_params))
-
-            if not response.ok:
-                logging.error(f"First login step failed: {response.status_code} - {response.text} - Response: {response.text[:100]}")
-                return False
-
-            try:
-                login_data: Dict[str, Any] = response.json()
-                self.user_id = str(login_data["data"]["user"]["id_user"])
-            except KeyError as ke:
-                logging.error(f"Key error during login: {str(ke)} - Response: {response.text}")
-                return False
-            except ValueError as ve:
-                logging.error(f"Value error during login: {str(ve)} - Response: {response.text}")
-                return False
-
-            # Second login endpoint
-            response: requests.Response = self.session.post(
-                "https://sport.nubapp.com/api/v4/login",
-                headers={"Content-Type": "application/x-www-form-urlencoded;charset=UTF-8"},
-                data=urlencode({
-                    "device_type": DEVICE_TYPE,
-                    "username": USERNAME,
-                    "password": PASSWORD
-                }))
-
-            if response.ok:
-                try:
-                    login_data: Dict[str, Any] = response.json()
-                    self.auth_token = login_data.get("token")
-                except KeyError as ke:
-                    logging.error(f"Key error during login: {str(ke)} - Response: {response.text}")
-                    return False
-                except ValueError as ve:
-                    logging.error(f"Value error during login: {str(ve)} - Response: {response.text}")
-                    return False
-
-                if self.auth_token and self.user_id:
-                    logging.info("Successfully logged in")
-                    return True
-            else:
-                logging.error(f"Login failed: {response.status_code} - {response.text} - Response: {response.text[:100]}")
-                return False
-
-        except requests.exceptions.JSONDecodeError:
-            logging.error("Failed to decode JSON response during login")
-            return False
-        except requests.exceptions.RequestException as e:
-            logging.error(f"Request error during login: {str(e)}")
-            return False
-        except Exception as e:
-            logging.error(f"Unexpected error during login: {str(e)}")
-            return False
-
-    def get_available_sessions(self, start_date: datetime, end_date: datetime) -> Optional[Dict[str, Any]]:
-        """
-        Fetch available sessions from the API with comprehensive error handling.
-        
-        Args:
-            start_date (datetime): Start date for fetching sessions.
-            end_date (datetime): End date for fetching sessions.
-            
-        Returns:
-            Optional[Dict[str, Any]]: Dictionary containing available sessions if successful, None otherwise.
-        """
-        if not self.auth_token or not self.user_id:
-            logging.error("Authentication required - missing token or user ID")
-            return None
-
-        url: str = "https://sport.nubapp.com/api/v4/activities/getActivitiesCalendar.php"
-
-        # Prepare request with mandatory parameters
-        request_data: Dict[str, str] = self.mandatory_params.copy()
-        request_data.update({
-            "id_user": self.user_id,
-            "start_timestamp": start_date.strftime("%d-%m-%Y"),
-            "end_timestamp": end_date.strftime("%d-%m-%Y")
-        })
-
-        # Add retry logic with exponential backoff and more informative error messages
-        for retry in range(RETRY_MAX):
-            try:
-                try:
-                    response: requests.Response = self.session.post(
-                        url,
-                        headers=get_auth_headers(self.base_headers, self.auth_token),
-                        data=urlencode(request_data),
-                        timeout=10
-                    )
-                except requests.exceptions.Timeout:
-                    logging.error(f"Request timed out after 10 seconds for URL: {url}. Retry {retry+1}/{RETRY_MAX}")
-                    return None
-                except requests.exceptions.ConnectionError as e:
-                    logging.error(f"Connection error for URL: {url} - Error: {str(e)}")
-                    return None
-                except requests.exceptions.RequestException as e:
-                    logging.error(f"Request failed for URL: {url} - Error: {str(e)}")
-                    return None
-                break  # Success, exit retry loop
-            except requests.exceptions.JSONDecodeError:
-                logging.error("Failed to decode JSON response")
-                return None
-            except requests.exceptions.RequestException as e:
-                if retry == RETRY_MAX - 1:
-                    logging.error(f"Final retry failed: {str(e)}")
-                    raise  # Propagate error
-                wait_time: int = RETRY_BACKOFF * (2 ** retry)
-                logging.warning(f"Request failed (attempt {retry+1}/{RETRY_MAX}): {str(e)}. Retrying in {wait_time}s...")
-                time.sleep(wait_time)
-        else:
-            # All retries exhausted
-            logging.error(f"Failed after {RETRY_MAX} attempts")
-            return None
-
-        # Handle response
-        if response.status_code == 200:
-            try:
-                json_response: Dict[str, Any] = response.json()
-                return json_response
-            except ValueError:
-                logging.error("Failed to decode JSON response")
-                return None
-        elif response.status_code == 400:
-            logging.error("400 Bad Request - likely missing or invalid parameters")
-            logging.error(f"Request Data: {request_data}")
-            logging.error(f"Response: {response.text[:100]}")
-            return None
-        elif response.status_code == 401:
-            logging.error("401 Unauthorized - token may be expired or invalid")
-            logging.error(f"Response: {response.text[:100]}")
-            return None
-        elif 500 <= response.status_code < 600:
-            logging.error(f"Server error {response.status_code} - Response: {response.text[:100]}")
-            raise requests.exceptions.ConnectionError(f"Server error {response.status_code}")
-        else:
-            logging.error(f"Unexpected status code: {response.status_code}")
-            return None
-
-    def book_session(self, session_id: str) -> bool:
-        """
-        Book a specific session with debug logging.
-        
-        Args:
-            session_id (str): ID of the session to book.
-            
-        Returns:
-            bool: True if booking is successful, False otherwise.
-        """
-        return self._make_request(
-            url="https://sport.nubapp.com/api/v4/activities/bookActivityCalendar.php",
-            data=prepare_booking_data(self.mandatory_params, session_id, self.user_id),
-            success_msg=f"Successfully booked session {session_id}"
-        )
-
-    def _make_request(self, url: str, data: Dict[str, str], success_msg: str) -> bool:
-        """
-        Handle API requests with retry logic and response processing.
-        
-        Args:
-            url (str): URL for the API request.
-            data (Dict[str, str]): Data to send with the request.
-            success_msg (str): Message to log on successful request.
-            
-        Returns:
-            bool: True if request is successful, False otherwise.
-        """
-        for retry in range(RETRY_MAX):
-            try:
-                response: requests.Response = self.session.post(
-                    url,
-                    headers=get_auth_headers(self.base_headers, self.auth_token),
-                    data=urlencode(data),
-                    timeout=10
-                )
-
-                if response.status_code == 200:
-                    json_response: Dict[str, Any] = response.json()
-                    if json_response.get("success", False):
-                        logging.info(success_msg)
-                        return True
-                    logging.error(f"API returned success:false: {json_response}")
-                    return False
-
-                logging.error(f"HTTP {response.status_code}: {response.text[:100]}")
-                return False
-
-            except requests.exceptions.JSONDecodeError:
-                logging.error("Failed to decode JSON response")
-                return False
-            except requests.exceptions.RequestException as e:
-                if retry == RETRY_MAX - 1:
-                    logging.error(f"Final retry failed: {str(e)}")
-                    raise  # Propagate error
-                wait_time: int = RETRY_BACKOFF * (2 ** retry)
-                logging.warning(f"Request failed (attempt {retry+1}/{RETRY_MAX}): {str(e)}. Retrying in {wait_time}s...")
-                time.sleep(wait_time)
-
-        logging.error(f"Failed to complete request after {RETRY_MAX} attempts")
-        return False
-
-    async def run_booking_cycle(self, current_time: datetime) -> None:
-        """
-        Run one cycle of checking and booking sessions.
-        
-        Args:
-            current_time (datetime): Current time for comparison.
-        """
-        # Calculate date range to check (current day, day + 1, and day + 2)
-        start_date: date = current_time.date()
-        end_date: date = start_date + timedelta(days=2)  # Only go up to day + 2
-
-        # Get available sessions
-        sessions_data: Optional[Dict[str, Any]] = self.get_available_sessions(start_date, end_date)
-        if not sessions_data or not sessions_data.get("success", False):
-            logging.error("No sessions available or error fetching sessions - Sessions Data: {sessions_data}")
-            return
-
-        activities: List[Dict[str, Any]] = sessions_data.get("data", {}).get("activities_calendar", [])
-
-        # Categorize sessions
-        categorized_sessions = categorize_sessions(activities, current_time, PREFERRED_SESSIONS, TIMEZONE)
-
-        if not categorized_sessions["bookable"] and not categorized_sessions["upcoming"]:
-            logging.info("No matching sessions found to book")
-            return
-
-        # Notify about all found preferred sessions, regardless of bookability
-        for session in categorized_sessions["all_preferred"]:
-            session_details = format_session_details(session, TIMEZONE)
-            await self.notifier.notify_session_booking(session_details)
-            logging.info(f"Notified about found preferred session: {session_details}")
-
-        # Notify about upcoming sessions
-        for session in categorized_sessions["upcoming"]:
-            session_details = format_session_details(session, TIMEZONE)
-            await self.notifier.notify_upcoming_session(session_details, 1)  # Days until is 1 for tomorrow
-            logging.info(f"Notified about upcoming session: {session_details}")
-
-        # Book sessions
-        for session in categorized_sessions["bookable"]:
-            session_time: datetime = datetime.strptime(session["start_timestamp"], "%Y-%m-%d %H:%M:%S")
-            logging.info(f"Attempting to book Preferred session at {session_time} ({session['name_activity']})")
-            booking_success = self.book_session(session["id_activity_calendar"])
-            
-            # Process booking result
-            result = process_booking_results(session, booking_success, TIMEZONE)
-            
-            if result["success"]:
-                # Send notification after successful booking
-                await self.notifier.notify_session_booking(result["details"])
-                logging.info(f"Successfully booked Preferred session at {session_time}")
-            else:
-                logging.error(f"Failed to book Preferred session at {session_time} - Session: {session}")
-                # Send notification about the failed booking
-                await self.notifier.notify_impossible_booking(result["details"])
-                logging.info(f"Notified about impossible booking for Preferred session at {session_time}")
-
-    async def run(self) -> None:
-        """
-        Main execution loop.
-        """
-        # Set up timezone
-        tz: pytz.timezone = pytz.timezone(TIMEZONE)
-
-        # Parse TARGET_RESERVATION_TIME to get the target hour and minute
-        target_hour, target_minute = map(int, TARGET_RESERVATION_TIME.split(":"))
-        target_time = datetime.now(tz).replace(hour=target_hour, minute=target_minute, second=0, microsecond=0)
-        booking_window_end = target_time + timedelta(hours=1)
-
-        # Initial login
-        if not self.login():
-            logging.error("Authentication failed - exiting program")
-            return
-
-        try:
-            while True:
-                try:
-                    current_time: datetime = datetime.now(tz)
-                    logging.info(f"Current time: {current_time}")
-
-                    # Only book sessions if current time is within the booking window
-                    if target_time <= current_time <= booking_window_end:
-                        # Run booking cycle to check for preferred sessions and book
-                        await self.run_booking_cycle(current_time)
-                        # Wait for a short time before next check
-                        time.sleep(60)
-                    else:
-                        # Check again in 5 minutes if outside booking window
-                        time.sleep(300)
-                except Exception as e:
-                    logging.error(f"Unexpected error in booking cycle: {str(e)} - Traceback: {traceback.format_exc()}")
-                    time.sleep(60)  # Wait before retrying after error
-        except KeyboardInterrupt:
-            self.quit()
-
-    def quit(self) -> None:
-        """
-        Clean up resources and exit the script.
-        """
-        logging.info("Script interrupted by user. Quitting...")
-        # Add any cleanup code here
-        exit(0)

docker-compose.yml

@@ -4,11 +4,13 @@ services:
     build:
       context: .
       dockerfile: Dockerfile
-    container_name: crossfit-booker
+    # container_name: crossfit-booker
     environment:
       - TZ=Europe/Paris
       - CROSSFIT_USERNAME=${CROSSFIT_USERNAME}
       - CROSSFIT_PASSWORD=${CROSSFIT_PASSWORD}
+      - TARGET_RESERVATION_TIME=${TARGET_RESERVATION_TIME}
+      - BOOKING_WINDOW_END_DELTA_MINUTES=${BOOKING_WINDOW_END_DELTA_MINUTES}
       - SMTP_SERVER=${SMTP_SERVER}
       - EMAIL_FROM=${EMAIL_FROM}
       - EMAIL_TO=${EMAIL_TO}
@@ -16,5 +18,5 @@ services:
       - TELEGRAM_TOKEN=${TELEGRAM_TOKEN}
       - TELEGRAM_CHAT_ID=${TELEGRAM_CHAT_ID}
     volumes:
-      - ./log:/app/log
-    restart: unless-stopped
+      - ./:/app
+    restart: unless-stopped

documents/crossfit.txt

@@ -23,21 +23,23 @@ curl 'https://sport.nubapp.com/api/v4/activities/getActivitiesCalendar.php' \
   -X POST \
   -H 'User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:140.0) Gecko/20100101 Firefox/140.0' \
   -H 'Accept: application/json, text/plain, */*' \
-  -H 'Accept-Language: en-GB,en;q=0.8,fr-FR;q=0.5,fr;q=0.3' \
+  -H 'Accept-Language: fr-FR,fr;q=0.8,en-GB;q=0.5,en;q=0.3' \
   -H 'Accept-Encoding: gzip, deflate, br, zstd' \
-  -H 'Referer: https://box.resawod.com/' \
   -H 'Content-Type: application/x-www-form-urlencoded' \
-  -H 'Authorization: Bearer eyJ0eXAiOiJKV1QiLCJhbGciOiJSUzI1NiJ9.eyJpYXQiOjE3NTI3NDI5ODYsImV4cCI6MTc2ODY0NDE4Niwicm9sZXMiOlsiUk9MRV9VU0VSIl0sImlkX3VzZXIiOjMxOTE0MjksImlkX2FwcGxpY2F0aW9uIjo4MTU2MDg4NywicGFzc3dvcmRfaGFzaCI6ImEzZGZiOGQzY2NhNTA5NmJhYzYxMWM4MmEwMzYyYTg2ODc3MjQ4MjIiLCJhdXRoZW50aWNhdGlvbl90eXBlIjoiYXBpIiwidXNlcm5hbWUiOiJLZXZpbjg0MDcifQ.BQ-o2-f0-Pj36nvnWz_ZVag6nWIlus5YPCh5tJSrt2XdpxvU6RYVbx4uobyicqS8jyK6G5OmQ1dJU8H5l3KRdK7enSFC4ClbyX7hXCRfQ0EW2bndNj_eIeR5qxbU8jgELCi6JTiCOouICdx6gkqvT9uYk4jSVdDWjYP9lATnzvNpwEIg2Aac1aqXflZtgFPSgwxEuotknLYFxRgMB6nTnMS34iIcvY4WVqsN_geYAtvhZM40NgEqK3Q4XMJusg7wStfiR7d8sqk-9Gqm3thE7Qsu-EjO9T7840zVyTWlLRa5TtUZiqDHjex-KYIh3p8xATbg_Ssct62o_FYkpN0XNA' \
+  -H 'Authorization: Bearer eyJ0eXAiOiJKV1QiLCJhbGciOiJSUzI1NiJ9.eyJpYXQiOjE3NTQ2NjQ4ODYsImV4cCI6MTc3MDU2NjA4Niwicm9sZXMiOlsiUk9MRV9VU0VSIl0sImlkX3VzZXIiOjMxOTE0MjksImlkX2FwcGxpY2F0aW9uIjo4MTU2MDg4NywicGFzc3dvcmRfaGFzaCI6ImEzZGZiOGQzY2NhNTA5NmJhYzYxMWM4MmEwMzYyYTg2ODc3MjQ4MjIiLCJhdXRoZW50aWNhdGlvbl90eXBlIjoiYXBpIiwidXNlcm5hbWUiOiJLZXZpbjg0MDcifQ.AuFvEW5dWWD1SVWwj6dVNOKpTCNeBzSY6HLtbz2z6KGh30VhMoswICWv6KcKqMNtJmt-UV5kpQkdfWAKOHZy843QGEnpI4scMAe1KUAl--Tn7pvwmTYxpx4Ta5E7f4DEV7m6YqZmdClOy-6YbDmf1qb-bR_v20gORMmutkdmcS8btteW11Lc2Uk6k8I2AWMulygQkV1PURzTIm7cmMNX0_R1Z_7M0HWsq_PLuZ0h0gaxKBS_BUqiMNeh8Hvu_sS56OPeDNRXQmFHuDI7CLMTNWBbmNAhfauIP293I8-cwC7eqjP_pp-v6zLTObHndJgNFEoce82iX11KCINyLryqcQ' \
   -H 'Nubapp-Origin: user_apps' \
   -H 'Origin: https://box.resawod.com' \
+  -H 'Sec-GPC: 1' \
   -H 'Connection: keep-alive' \
+  -H 'Referer: https://box.resawod.com/' \
   -H 'Sec-Fetch-Dest: empty' \
   -H 'Sec-Fetch-Mode: cors' \
   -H 'Sec-Fetch-Site: cross-site' \
+  -H 'Priority: u=0' \
   -H 'TE: trailers' \
-  --data-raw 'app_version=5.09.21&id_application=81560887&id_user=3191429&start_timestamp=21-07-2025&end_timestamp=27-07-2025&id_category_activity=677'
+  --data-raw 'app_version=5.09.25&id_application=81560887&id_user=3191429&start_timestamp=04-08-2025&end_timestamp=10-08-2025&id_category_activity=677'
 
-Book activity
+## Book activity
 
   curl 'https://sport.nubapp.com/api/v4/activities/bookActivityCalendar.php' \
   -X POST \
@@ -47,7 +49,7 @@ Book activity
   -H 'Accept-Encoding: gzip, deflate, br, zstd' \
   -H 'Referer: https://box.resawod.com/' \
   -H 'Content-Type: application/x-www-form-urlencoded' \
-  -H 'Authorization: Bearer eyJ0eXAiOiJKV1QiLCJhbGciOiJSUzI1NiJ9.eyJpYXQiOjE3NTI2NzYwNDksImV4cCI6MTc2ODU3NzI0OSwicm9sZXMiOlsiUk9MRV9VU0VSIl0sImlkX3VzZXIiOjMxOTE0MjksImlkX2FwcGxpY2F0aW9uIjo4MTU2MDg4NywicGFzc3dvcmRfaGFzaCI6ImEzZGZiOGQzY2NhNTA5NmJhYzYxMWM4MmEwMzYyYTg2ODc3MjQ4MjIiLCJhdXRoZW50aWNhdGlvbl90eXBlIjoiYXBpIiwidXNlcm5hbWUiOiJLZXZpbjg0MDcifQ.mQhKOTtEt1QUwDzK7BGzA3yk1R4RozhQW1xqfhmfmk_mesrkz5RM9IOnLFbP-ZMvx4_9ZlWv4qvgx3XjAzDWf8M86BPWhY6nNAoKAdTbD_Pg-fsjmRVVEadNv0pizavue5--K2XvU50AQinkzHawihm7HtTqcWOJgH3J7PM5NQO0Y1azd2nkt9mqTBf1l5MrvDZPWR_KbiztNavacr5SY9vSk1pfnf1A9jbR9ca3wCxZNKhXfxCWxNHCBqh_VnXP3Wwh518xL94xCx0nziKDR5VQYNQCLTO3cb9lDTmCILgZSnvSXIpFVNw1mTkz34MKS2WCkF540okzIFTooNhf_A' \
+  -H 'Authorization: Bearer eyJ0eXAiOiJKV1QiLCJhbGciOiJSUzI1NiJ9.eyJpYXQiOjE3NTQ2NjQ4ODYsImV4cCI6MTc3MDU2NjA4Niwicm9sZXMiOlsiUk9MRV9VU0VSIl0sImlkX3VzZXIiOjMxOTE0MjksImlkX2FwcGxpY2F0aW9uIjo4MTU2MDg4NywicGFzc3dvcmRfaGFzaCI6ImEzZGZiOGQzY2NhNTA5NmJhYzYxMWM4MmEwMzYyYTg2ODc3MjQ4MjIiLCJhdXRoZW50aWNhdGlvbl90eXBlIjoiYXBpIiwidXNlcm5hbWUiOiJLZXZpbjg0MDcifQ.AuFvEW5dWWD1SVWwj6dVNOKpTCNeBzSY6HLtbz2z6KGh30VhMoswICWv6KcKqMNtJmt-UV5kpQkdfWAKOHZy843QGEnpI4scMAe1KUAl--Tn7pvwmTYxpx4Ta5E7f4DEV7m6YqZmdClOy-6YbDmf1qb-bR_v20gORMmutkdmcS8btteW11Lc2Uk6k8I2AWMulygQkV1PURzTIm7cmMNX0_R1Z_7M0HWsq_PLuZ0h0gaxKBS_BUqiMNeh8Hvu_sS56OPeDNRXQmFHuDI7CLMTNWBbmNAhfauIP293I8-cwC7eqjP_pp-v6zLTObHndJgNFEoce82iX11KCINyLryqcQ' \
   -H 'Nubapp-Origin: user_apps' \
   -H 'Origin: https://box.resawod.com' \
   -H 'Connection: keep-alive' \
@@ -56,7 +58,7 @@ Book activity
   -H 'Sec-Fetch-Site: cross-site' \
   -H 'Priority: u=0' \
   -H 'TE: trailers' \
-  --data-raw 'app_version=5.09.21&id_application=81560887^&id_activity_calendar=19291304&id_user=3191429&action_by=3191429&n_guests=0&booked_on=3'
+  --data-raw 'app_version=5.09.21&id_application=81560887^&id_activity_calendar=19291766&id_user=3191429&action_by=3191429&n_guests=0&booked_on=3'
 
 
 

main.py

@@ -0,0 +1,77 @@
+#!/usr/bin/env python3
+"""
+Main entry point for the CrossFit Booker application.
+This script initializes the CrossFitBooker and starts the booking process.
+"""
+
+import logging
+import os
+from src.auth import AuthHandler
+from src.booker import Booker
+from src.session_notifier import SessionNotifier
+
+# Load environment variables
+from dotenv import load_dotenv
+load_dotenv()
+
+def main():
+    """
+    Main function to initialize the Booker and start the booking process.
+    """
+    # Set up logging
+    logging.basicConfig(
+        level=logging.INFO,
+        format='%(asctime)s - %(levelname)s - %(message)s',
+        handlers=[
+            logging.StreamHandler()
+        ]
+    )
+
+    # Display ASCII art and username
+    try:
+        with open('ascii.md', 'r') as f:
+            ascii_art = f.read()
+        print(ascii_art, flush=True)
+        username = os.environ.get("CROSSFIT_USERNAME")
+        print(f"Username: {username}", flush=True)
+        print(flush=True)
+    except Exception as e:
+        logging.error(f"Error displaying ASCII: {e}")
+
+    # Initialize components
+    auth_handler = AuthHandler(
+        str(os.environ.get("CROSSFIT_USERNAME")),
+        str(os.environ.get("CROSSFIT_PASSWORD"))
+    )
+
+    # Initialize notification system
+    email_credentials = {
+        "from": os.environ.get("EMAIL_FROM"),
+        "to": os.environ.get("EMAIL_TO"),
+        "password": os.environ.get("EMAIL_PASSWORD")
+    }
+
+    telegram_credentials = {
+        "token": os.environ.get("TELEGRAM_TOKEN"),
+        "chat_id": os.environ.get("TELEGRAM_CHAT_ID")
+    }
+
+    enable_email = os.environ.get("ENABLE_EMAIL_NOTIFICATIONS", "true").lower() in ("true", "1", "yes")
+    enable_telegram = os.environ.get("ENABLE_TELEGRAM_NOTIFICATIONS", "true").lower() in ("true", "1", "yes")
+
+    notifier = SessionNotifier(
+        email_credentials,
+        telegram_credentials,
+        enable_email=enable_email,
+        enable_telegram=enable_telegram
+    )
+
+    # Initialize the Booker
+    booker = Booker(auth_handler, notifier)
+
+    # Run the booking process
+    import asyncio
+    asyncio.run(booker.run())
+
+if __name__ == "__main__":
+    main()

preferred_sessions.json

@@ -1,17 +0,0 @@
-[
-    {
-        "day_of_week": 2,
-        "start_time": "18:30",
-        "session_name_contains": "CONDITIONING"
-    },
-    {
-        "day_of_week": 4,
-        "start_time": "17:00",
-        "session_name_contains": "WEIGHTLIFTING"
-    },
-    {
-        "day_of_week": 5,
-        "start_time": "12:30",
-        "session_name_contains": "HYROX"
-    }
-]

preferred_sessions.json.example

@@ -0,0 +1,22 @@
+[
+    {
+        "day_of_week": 0,
+        "start_time": "17:45",
+        "session_name_contains": "WEIGHTLIFTING LOUVRE 3"
+    },
+    {
+        "day_of_week": 4,
+        "start_time": "17:00",
+        "session_name_contains": "CONDITIONING LOUVRE 3"
+    },
+    {
+        "day_of_week": 5,
+        "start_time": "12:30",
+        "session_name_contains": "HYROX"
+    },
+    {
+        "day_of_week": 5,
+        "start_time": "12:30",
+        "session_name_contains": "CONDITIONING"
+    }
+]

scripts/execute_book_session.py

@@ -0,0 +1,80 @@
+#!/usr/bin/env python3
+"""
+Script to demonstrate how to execute the book_session method from crossfit_booker.py
+"""
+
+import sys
+import os
+import logging
+from src.auth import AuthHandler
+from src.booker import Booker
+from src.session_notifier import SessionNotifier
+
+# Load environment variables
+from dotenv import load_dotenv
+load_dotenv()
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
+def main():
+    # Check if a session ID was provided as an argument
+    if len(sys.argv) < 2:
+        print("Usage: python execute_book_session.py <session_id>")
+        sys.exit(1)
+
+    session_id = sys.argv[1]
+
+    # Initialize components
+    auth_handler = AuthHandler(
+        os.environ.get("CROSSFIT_USERNAME"),
+        os.environ.get("CROSSFIT_PASSWORD")
+    )
+
+    # Initialize notification system (minimal for single session booking)
+    email_credentials = {
+        "from": os.environ.get("EMAIL_FROM"),
+        "to": os.environ.get("EMAIL_TO"),
+        "password": os.environ.get("EMAIL_PASSWORD")
+    }
+
+    telegram_credentials = {
+        "token": os.environ.get("TELEGRAM_TOKEN"),
+        "chat_id": os.environ.get("TELEGRAM_CHAT_ID")
+    }
+
+    enable_email = os.environ.get("ENABLE_EMAIL_NOTIFICATIONS", "true").lower() in ("true", "1", "yes")
+    enable_telegram = os.environ.get("ENABLE_TELEGRAM_NOTIFICATIONS", "true").lower() in ("true", "1", "yes")
+
+    notifier = SessionNotifier(
+        email_credentials,
+        telegram_credentials,
+        enable_email=enable_email,
+        enable_telegram=enable_telegram
+    )
+
+    # Create an instance of Booker
+    booker = Booker(auth_handler, notifier)
+
+    # Login to authenticate
+    print("Attempting to authenticate...")
+    if not auth_handler.login():
+        print("Failed to authenticate. Please check your credentials and try again.")
+        sys.exit(1)
+    print("Authentication successful!")
+
+    # Book the session
+    print(f"Attempting to book session with ID: {session_id}")
+    success = booker.book_session(session_id)
+
+    if success:
+        print(f"Successfully booked session {session_id}")
+    else:
+        print(f"Failed to book session {session_id}")
+
+if __name__ == "__main__":
+    try:
+        main()
+    except Exception as e:
+        print(f"An error occurred: {e}")
+        sys.exit(1)

scripts/test_book_session.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+# Test script to demonstrate how to use the execute_book_session.py script
+
+# Sample session ID (this should be a valid session ID from the crossfit booking system)
+SESSION_ID="19291768"
+
+# Run the script with the sample session ID
+echo "Attempting to book session with ID: $SESSION_ID"
+python execute_book_session.py $SESSION_ID

setup.py

@@ -0,0 +1,14 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="crossfit_booker",
+    version="0.1",
+    packages=find_packages(where="src"),
+    package_dir={"": "src"},
+    install_requires=[
+        "requests",
+        "python-dotenv",
+        "pytz",
+        "python-dateutil",
+    ],
+)

src/__init__.py

@@ -0,0 +1,16 @@
+# src/__init__.py
+
+# Import all public modules to make them available as src.module
+from .auth import AuthHandler
+from .booker import Booker
+from .session_config import PREFERRED_SESSIONS
+from .session_manager import SessionManager
+from .session_notifier import SessionNotifier
+
+__all__ = [
+    "AuthHandler",
+    "Booker",
+    "PREFERRED_SESSIONS",
+    "SessionManager",
+    "SessionNotifier"
+]

src/auth.py

@@ -0,0 +1,121 @@
+# Native modules
+import logging
+from typing import Dict, Any, Optional
+
+# Third-party modules
+import requests
+from urllib.parse import urlencode
+
+# Configuration constants (will be moved from crossfit_booker.py)
+APPLICATION_ID = "81560887"
+DEVICE_TYPE = "3"
+APP_VERSION = "5.09.21"
+
+class AuthHandler:
+    """
+    A class for handling authentication with the CrossFit booking system.
+    This class is responsible for performing login, retrieving auth tokens,
+    and providing authentication headers.
+    """
+
+    def __init__(self, username: str, password: str) -> None:
+        """
+        Initialize the AuthHandler with credentials.
+
+        Args:
+            username (str): The username for authentication.
+            password (str): The password for authentication.
+        """
+        self.username = username
+        self.password = password
+        self.auth_token: Optional[str] = None
+        self.user_id: Optional[str] = None
+        self.session = requests.Session()
+        self.base_headers: Dict[str, str] = {
+            "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:140.0) Gecko/20100101 Firefox/140.0",
+            "Content-Type": "application/x-www-form-urlencoded",
+            "Nubapp-Origin": "user_apps",
+        }
+        self.session.headers.update(self.base_headers)
+
+    def get_auth_headers(self) -> Dict[str, str]:
+        """
+        Return headers with authorization if available.
+
+        Returns:
+            Dict[str, str]: Headers dictionary with authorization if available.
+        """
+        headers: Dict[str, str] = self.base_headers.copy()
+        if self.auth_token:
+            headers["Authorization"] = f"Bearer {self.auth_token}"
+        return headers
+
+    def login(self) -> bool:
+        """
+        Authenticate and get the bearer token.
+
+        Returns:
+            bool: True if login is successful, False otherwise.
+        """
+        try:
+            # First login endpoint
+            login_params: Dict[str, str] = {
+                "app_version": APP_VERSION,
+                "device_type": DEVICE_TYPE,
+                "username": self.username,
+                "password": self.password
+            }
+
+            response: requests.Response = self.session.post(
+                "https://sport.nubapp.com/api/v4/users/checkUser.php",
+                headers={"Content-Type": "application/x-www-form-urlencoded"},
+                data=urlencode(login_params))
+
+            if not response.ok:
+                logging.error(f"First login step failed: {response.status_code} - {response.text[:100]}")
+                return False
+
+            try:
+                login_data: Dict[str, Any] = response.json()
+                # Try to find id_user in the nested structure
+                try:
+                    # First try the new structure: data.user.applications[0].users[0].id_user
+                    self.user_id = str(login_data["data"]["user"]["applications"][0]["users"][0]["id_user"])
+                except (KeyError, IndexError, TypeError):
+                    # Fallback to old structure if it exists
+                    self.user_id = str(login_data["data"]["user"]["id_user"])
+            except (KeyError, ValueError) as e:
+                logging.error(f"Error during login: {str(e)} - Response: {response.text}")
+                return False
+
+            # Second login endpoint
+            response: requests.Response = self.session.post(
+                "https://sport.nubapp.com/api/v4/login",
+                headers={"Content-Type": "application/x-www-form-urlencoded;charset=UTF-8"},
+                data=urlencode({
+                    "device_type": DEVICE_TYPE,
+                    "username": self.username,
+                    "password": self.password
+                }))
+
+            if response.ok:
+                try:
+                    login_data: Dict[str, Any] = response.json()
+                    self.auth_token = login_data.get("token")
+                except (KeyError, ValueError) as e:
+                    logging.error(f"Error during login: {str(e)} - Response: {response.text}")
+                    return False
+
+                if self.auth_token and self.user_id:
+                    logging.info("Successfully logged in")
+                    return True
+            else:
+                logging.error(f"Login failed: {response.status_code} - {response.text[:100]}")
+                return False
+
+        except requests.exceptions.RequestException as e:
+            logging.error(f"Request error during login: {str(e)}")
+            return False
+        except Exception as e:
+            logging.error(f"Unexpected error during login: {str(e)}")
+            return False

src/book_crossfit.py

@@ -0,0 +1,70 @@
+#!/usr/bin/env python3
+
+import logging
+import os
+import traceback
+from src.auth import AuthHandler
+from src.booker import Booker
+from src.session_notifier import SessionNotifier
+
+# Load environment variables
+from dotenv import load_dotenv
+load_dotenv()
+
+if __name__ == "__main__":
+    # Configure logging once at script startup
+    logging.basicConfig(
+        level=logging.DEBUG,  # Change to DEBUG for more detailed logs
+        format='%(asctime)s - %(levelname)s - %(message)s',
+        handlers=[
+            logging.FileHandler("log/crossfit_booking.log"),
+            logging.StreamHandler()
+        ]
+    )
+
+    # Reduce the verbosity of the requests library's logging
+    logging.getLogger("requests").setLevel(logging.WARNING)
+    logging.info("Logging enhanced with request library noise reduction")
+
+    # Initialize components
+    auth_handler = AuthHandler(
+        os.environ.get("CROSSFIT_USERNAME"),
+        os.environ.get("CROSSFIT_PASSWORD")
+    )
+
+    # Initialize notification system
+    email_credentials = {
+        "from": os.environ.get("EMAIL_FROM"),
+        "to": os.environ.get("EMAIL_TO"),
+        "password": os.environ.get("EMAIL_PASSWORD")
+    }
+
+    telegram_credentials = {
+        "token": os.environ.get("TELEGRAM_TOKEN"),
+        "chat_id": os.environ.get("TELEGRAM_CHAT_ID")
+    }
+
+    enable_email = os.environ.get("ENABLE_EMAIL_NOTIFICATIONS", "true").lower() in ("true", "1", "yes")
+    enable_telegram = os.environ.get("ENABLE_TELEGRAM_NOTIFICATIONS", "true").lower() in ("true", "1", "yes")
+
+    notifier = SessionNotifier(
+        email_credentials,
+        telegram_credentials,
+        enable_email=enable_email,
+        enable_telegram=enable_telegram
+    )
+
+    # Create an instance of the Booker class
+    booker = Booker(auth_handler, notifier)
+
+    # Attempt to log in to the CrossFit booking system
+    # TODO: Make a authentication during running request to not get kicked out
+    if not auth_handler.login():
+        # If login fails, log the error and exit the script
+        logging.error("Failed to login - Traceback: %s", traceback.format_exc())
+        exit(1)
+
+    # Start the continuous booking loop
+    import asyncio
+    asyncio.run(booker.run())
+    logging.info("Script completed")

src/booker.py

@@ -0,0 +1,309 @@
+# Native modules
+import logging
+import traceback
+import os
+import time
+from datetime import datetime, timedelta, date
+
+# Third-party modules
+import requests
+from dateutil.parser import parse
+import pytz
+from dotenv import load_dotenv
+from typing import List, Dict, Optional, Any
+
+# Import the SessionNotifier class
+from src.session_notifier import SessionNotifier
+
+# Import the preferred sessions from the session_config module
+
+# Import the AuthHandler class
+from src.auth import AuthHandler
+
+# Import SessionManager
+from src.session_manager import SessionManager
+
+load_dotenv()
+
+# Configuration
+USERNAME = os.environ.get("CROSSFIT_USERNAME")
+PASSWORD = os.environ.get("CROSSFIT_PASSWORD")
+
+if not all([USERNAME, PASSWORD]):
+    raise ValueError("Missing environment variables: CROSSFIT_USERNAME and/or CROSSFIT_PASSWORD")
+
+APPLICATION_ID = "81560887"
+CATEGORY_ID = "677"  # Activity category ID for CrossFit
+TIMEZONE = "Europe/Paris"  # Adjust to your timezone
+# Booking window configuration (can be overridden by environment variables)
+# TARGET_RESERVATION_TIME: string "HH:MM" local time when bookings open (default 20:01)
+# BOOKING_WINDOW_END_DELTA_MINUTES: int minutes after target time to stop booking (default 10)
+TARGET_RESERVATION_TIME = os.environ.get("TARGET_RESERVATION_TIME", "20:01")
+BOOKING_WINDOW_END_DELTA_MINUTES = int(os.environ.get("BOOKING_WINDOW_END_DELTA_MINUTES", "10"))
+DEVICE_TYPE = "3"
+
+# Retry configuration
+RETRY_MAX = 3
+RETRY_BACKOFF = 1
+APP_VERSION = "5.09.21"
+
+class Booker:
+    """
+    A class for handling the main booking logic.
+    This class is designed to be used as a standalone component
+    that can be initialized with authentication and session management
+    and used to perform the booking process.
+    """
+
+    def __init__(self, auth_handler: AuthHandler, notifier: SessionNotifier) -> None:
+        """
+        Initialize the Booker with necessary attributes.
+
+        Args:
+            auth_handler (AuthHandler): AuthHandler instance for authentication.
+            notifier (SessionNotifier): SessionNotifier instance for sending notifications.
+        """
+        self.auth_handler = auth_handler
+        self.notifier = notifier
+
+        # Initialize the session and headers
+        self.session: requests.Session = requests.Session()
+        self.base_headers: Dict[str, str] = {
+            "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:140.0) Gecko/20100101 Firefox/140.0",
+            "Content-Type": "application/x-www-form-urlencoded",
+            "Nubapp-Origin": "user_apps",
+        }
+        self.session.headers.update(self.base_headers)
+
+        # Define mandatory parameters for API calls
+        self.mandatory_params: Dict[str, str] = {
+            "app_version": APP_VERSION,
+            "device_type": DEVICE_TYPE,
+            "id_application": APPLICATION_ID,
+            "id_category_activity": CATEGORY_ID
+        }
+
+    def get_auth_headers(self) -> Dict[str, str]:
+        """
+        Return headers with authorization from the AuthHandler.
+
+        Returns:
+            Dict[str, str]: Headers dictionary with authorization if available.
+        """
+        return self.auth_handler.get_auth_headers()
+
+    async def booker(self, current_time: datetime) -> None:
+        """
+        Run one cycle of checking and booking sessions.
+
+        Args:
+            current_time (datetime): Current time for comparison.
+        """
+        # Calculate date range to check (current day, day + 1, and day + 2)
+        start_date: date = current_time.date()
+        end_date: date = start_date + timedelta(days=2)  # Only go up to day + 2
+
+        # Get available sessions
+        sessions_data: Optional[Dict[str, Any]] = self.get_available_sessions(start_date, end_date)
+        if not sessions_data or not sessions_data.get("success", False):
+            logging.error("No sessions available or error fetching sessions")
+            return
+
+        activities: List[Dict[str, Any]] = sessions_data.get("data", {}).get("activities_calendar", [])
+
+        # Display all available sessions within the date range
+        self.display_upcoming_sessions(activities, current_time)
+
+        # Find sessions to book (preferred only) within allowed date range
+        found_preferred_sessions: List[Dict[str, Any]] = []
+
+        for session in activities:
+            session_time: datetime = parse(session["start_timestamp"])
+            if not session_time.tzinfo:
+                session_time = pytz.timezone(TIMEZONE).localize(session_time)
+
+            # Check if session is within allowed date range (current day, day + 1, or day + 2)
+            days_diff = (session_time.date() - current_time.date()).days
+            if not (0 <= days_diff <= 2):
+                continue  # Skip sessions outside the allowed date range
+
+            # Check if session is preferred and bookable
+            if self.is_session_bookable(session, current_time):
+                if self.matches_preferred_session(session, current_time):
+                    found_preferred_sessions.append(session)
+
+        # Display preferred sessions found
+        if found_preferred_sessions:
+            logging.info("Preferred sessions found:")
+            for session in found_preferred_sessions:
+                session_time: datetime = parse(session["start_timestamp"])
+                if not session_time.tzinfo:
+                    session_time = pytz.timezone(TIMEZONE).localize(session_time)
+                logging.info(f"ID: {session['id_activity_calendar']}, Name: {session['name_activity']}, Time: {session_time.strftime('%Y-%m-%d %H:%M')}")
+        else:
+            logging.info("No matching preferred sessions found")
+
+        # Book preferred sessions
+        if not found_preferred_sessions:
+            logging.info("No matching sessions found to book")
+            return
+
+        # Book sessions (preferred first)
+        sessions_to_book = [("Preferred", session) for session in found_preferred_sessions]
+        sessions_to_book.sort(key=lambda x: 0 if x[0] == "Preferred" else 1)
+        booked_sessions = []
+
+        for session_type, session in sessions_to_book:
+            session_time: datetime = parse(session["start_timestamp"])
+            logging.info(f"Attempting to book {session_type} session at {session_time} ({session['name_activity']})")
+            if self.book_session(session["id_activity_calendar"]):
+                # Display booked session
+                booked_sessions.append(session)
+                logging.info(f"Successfully booked {session_type} session at {session_time}")
+
+                # Notify about booked session
+                session_details = f"ID: {session['id_activity_calendar']}, Name: {session['name_activity']}, Date: {session_time.strftime('%Y-%m-%d %H:%M')}"
+                await self.notifier.notify_session_booking(session_details)
+            else:
+                logging.error(f"Failed to book {session_type} session at {session_time}")
+
+                # Notify about failed booking
+                session_details = f"ID: {session['id_activity_calendar']}, Name: {session['name_activity']}, Date: {session_time.strftime('%Y-%m-%d %H:%M')}"
+                await self.notifier.notify_impossible_booking(session_details)
+                logging.info(f"Notified about impossible booking for {session_type} session at {session_time}")
+
+        # Display all booked session(s)
+        if booked_sessions:
+            logging.info("Booked sessions:")
+            for session in booked_sessions:
+                session_time: datetime = parse(session["start_timestamp"])
+                if not session_time.tzinfo:
+                    session_time = pytz.timezone(TIMEZONE).localize(session_time)
+                logging.info(f"ID: {session['id_activity_calendar']}, Name: {session['name_activity']}, Time: {session_time.strftime('%Y-%m-%d %H:%M')}")
+        else:
+            logging.info("No sessions were booked")
+
+    async def run(self) -> None:
+        """
+        Main execution loop.
+        """
+        # Set up timezone
+        tz: pytz.timezone = pytz.timezone(TIMEZONE)
+
+        # Parse TARGET_RESERVATION_TIME to get the target hour and minute
+        target_hour, target_minute = map(int, TARGET_RESERVATION_TIME.split(":"))
+
+        # Initial login
+        if not self.auth_handler.login():
+            logging.error("Authentication failed - exiting program")
+            return
+
+        try:
+            while True:
+                try:
+                    current_time: datetime = datetime.now(tz)
+                    logging.info(f"Current time: {current_time}")
+
+                    # Recalculate target time and end time for the current day
+                    today_target_time = current_time.replace(hour=target_hour, minute=target_minute, second=0, microsecond=0)
+                    booking_window_end = today_target_time + timedelta(minutes=BOOKING_WINDOW_END_DELTA_MINUTES)
+
+                    # Only book sessions if current time is within the booking window
+                    if today_target_time <= current_time <= booking_window_end:
+                        # Run booking cycle to check for preferred sessions and book
+                        await self.booker(current_time)
+                        # Wait for a short time before next check
+                        time.sleep(60)
+                    else:
+                        # Display message when outside booking window
+                        # logging.info(f"Not booking now - current time {current_time} is outside the booking window ({today_target_time} to {booking_window_end})")
+                        # Check again in 5 minutes if outside booking window
+                        time.sleep(300)
+                except Exception as e:
+                    logging.error(f"Unexpected error in booking cycle: {str(e)} - Traceback: {traceback.format_exc()}")
+                    time.sleep(60)  # Wait before retrying after error
+        except KeyboardInterrupt:
+            self.quit()
+
+    def quit(self) -> None:
+        """
+        Clean up resources and exit the script.
+        """
+        logging.info("Script interrupted by user. Quitting...")
+        exit(0)
+
+    def get_available_sessions(self, start_date: date, end_date: date) -> Optional[Dict[str, Any]]:
+        """
+        Fetch available sessions from the API.
+
+        Args:
+            start_date (date): Start date for fetching sessions.
+            end_date (date): End date for fetching sessions.
+
+        Returns:
+            Optional[Dict[str, Any]]: Dictionary containing available sessions if successful, None otherwise.
+        """
+        session_manager = SessionManager(self.auth_handler)
+        return session_manager.get_available_sessions(start_date, end_date)
+
+    def book_session(self, session_id: str) -> bool:
+        """
+        Book a specific session.
+
+        Args:
+            session_id (str): ID of the session to book.
+
+        Returns:
+            bool: True if booking is successful, False otherwise.
+        """
+        session_manager = SessionManager(self.auth_handler)
+        return session_manager.book_session(session_id)
+
+    def get_booked_sessions(self) -> List[Dict[str, Any]]:
+        """
+        Get a list of booked sessions.
+
+        Returns:
+            A list of dictionaries containing information about the booked sessions.
+        """
+        session_manager = SessionManager(self.auth_handler)
+        return session_manager.get_booked_sessions()
+
+    def is_session_bookable(self, session: Dict[str, Any], current_time: datetime) -> bool:
+        """
+        Check if a session is bookable based on user_info.
+
+        Args:
+            session (Dict[str, Any]): Session data.
+            current_time (datetime): Current time for comparison.
+
+        Returns:
+            bool: True if the session is bookable, False otherwise.
+        """
+        session_manager = SessionManager(self.auth_handler)
+        return session_manager.is_session_bookable(session, current_time)
+
+    def matches_preferred_session(self, session: Dict[str, Any], current_time: datetime) -> bool:
+        """
+        Check if session matches one of your preferred sessions with exact matching.
+
+        Args:
+            session (Dict[str, Any]): Session data.
+            current_time (datetime): Current time for comparison.
+
+        Returns:
+            bool: True if the session matches a preferred session, False otherwise.
+        """
+        session_manager = SessionManager(self.auth_handler)
+        return session_manager.matches_preferred_session(session, current_time)
+
+    def display_upcoming_sessions(self, sessions: List[Dict[str, Any]], current_time: datetime) -> None:
+        """
+        Display upcoming sessions with ID, name, date, and time.
+
+        Args:
+            sessions (List[Dict[str, Any]]): List of session data.
+            current_time (datetime): Current time for comparison.
+        """
+        session_manager = SessionManager(self.auth_handler)
+        session_manager.display_upcoming_sessions(sessions, current_time)

src/session_config.py

@@ -36,20 +36,19 @@ class SessionConfig:
                     preferred_sessions.append((day_of_week, start_time, session_name_contains))
 
         except FileNotFoundError:
-            # Log a warning if the file is not found
-            logging.warning(f"Configuration file '{config_file}' not found. Falling back to default settings.")
+            # Log error and exit if the file is not found
+            logging.error(f"Configuration file '{config_file}' not found. Please create the configuration file.")
+            logging.error("You can copy 'preferred_sessions.json.example' to 'preferred_sessions.json' as a template.")
+            raise SystemExit(1)
 
         except json.JSONDecodeError:
-            # Log a warning if the file is not a valid JSON
-            logging.warning(f"Failed to decode JSON from file '{config_file}'. Falling back to default settings.")
+            # Log error and exit if the file is not a valid JSON
+            logging.error(f"Failed to decode JSON from file '{config_file}'. Please check the file format.")
+            raise SystemExit(1)
 
-        # Fallback to default hardcoded sessions if no valid sessions were loaded
+        # Return empty list if no valid sessions were loaded
         if not preferred_sessions:
-            preferred_sessions = [
-                (2, "18:30", "CONDITIONING"),   # Wednesday 18:30 CONDITIONING
-                (4, "17:00", "WEIGHTLIFTING"),  # Friday 17:00 WEIGHTLIFTING
-                (5, "12:30", "HYROX"),          # Saturday 12:30 HYROX
-            ]
+            return []
 
         return preferred_sessions
 

src/session_manager.py

@@ -0,0 +1,314 @@
+# Native modules
+import logging
+import pytz
+import time
+from datetime import date
+from typing import List, Dict, Optional, Any
+from datetime import datetime
+
+# Third-party modules
+import requests
+from dateutil.parser import parse
+
+# Import the preferred sessions from the session_config module
+from src.session_config import PREFERRED_SESSIONS
+
+# Import the AuthHandler class
+from src.auth import AuthHandler
+
+class SessionManager:
+    """
+    A class for managing CrossFit sessions.
+    This class handles session availability checking, booking,
+    and session-related operations.
+    """
+
+    def __init__(self, auth_handler: AuthHandler) -> None:
+        """
+        Initialize the SessionManager with necessary attributes.
+
+        Args:
+            auth_handler (AuthHandler): AuthHandler instance for authentication.
+        """
+        self.auth_handler = auth_handler
+        self.session = requests.Session()
+        self.base_headers = {
+            "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:140.0) Gecko/20100101 Firefox/140.0",
+            "Content-Type": "application/x-www-form-urlencoded",
+            "Nubapp-Origin": "user_apps",
+        }
+        self.session.headers.update(self.base_headers)
+
+        # Define mandatory parameters for API calls
+        self.mandatory_params = {
+            "app_version": "5.09.21",
+            "device_type": "3",
+            "id_application": "81560887",
+            "id_category_activity": "677"
+        }
+
+    def get_auth_headers(self) -> Dict[str, str]:
+        """
+        Return headers with authorization from the AuthHandler.
+
+        Returns:
+            Dict[str, str]: Headers dictionary with authorization if available.
+        """
+        return self.auth_handler.get_auth_headers()
+
+    def get_available_sessions(self, start_date: date, end_date: date) -> Optional[Dict[str, Any]]:
+        """
+        Fetch available sessions from the API.
+
+        Args:
+            start_date (date): Start date for fetching sessions.
+            end_date (date): End date for fetching sessions.
+
+        Returns:
+            Optional[Dict[str, Any]]: Dictionary containing available sessions if successful, None otherwise.
+        """
+        if not self.auth_handler.auth_token or not self.auth_handler.user_id:
+            logging.error("Authentication required - missing token or user ID")
+            return None
+
+        url = "https://sport.nubapp.com/api/v4/activities/getActivitiesCalendar.php"
+
+        # Prepare request with mandatory parameters
+        request_data = self.mandatory_params.copy()
+        request_data.update({
+            "id_user": self.auth_handler.user_id,
+            "start_timestamp": start_date.strftime("%d-%m-%Y"),
+            "end_timestamp": end_date.strftime("%d-%m-%Y")
+        })
+
+        # Add retry logic
+        for retry in range(3):
+            try:
+                response = self.session.post(
+                    url,
+                    headers=self.get_auth_headers(),
+                    data=request_data,
+                    timeout=10
+                )
+
+                if response.status_code == 200:
+                    return response.json()
+                elif response.status_code == 401:
+                    logging.error("401 Unauthorized - token may be expired or invalid")
+                    return None
+                elif 500 <= response.status_code < 600:
+                    logging.error(f"Server error {response.status_code}")
+                    raise requests.exceptions.ConnectionError(f"Server error {response.status_code}")
+                else:
+                    logging.error(f"Unexpected status code: {response.status_code} - {response.text[:100]}")
+                    return None
+
+            except requests.exceptions.RequestException as e:
+                if retry == 2:
+                    logging.error(f"Final retry failed: {str(e)}")
+                    raise
+                wait_time = 1 * (2 ** retry)
+                logging.warning(f"Request failed (attempt {retry+1}/3): {str(e)}. Retrying in {wait_time}s...")
+                time.sleep(wait_time)
+
+        return None
+
+    def book_session(self, session_id: str) -> bool:
+        """
+        Book a specific session.
+
+        Args:
+            session_id (str): ID of the session to book.
+
+        Returns:
+            bool: True if booking is successful, False otherwise.
+        """
+        url = "https://sport.nubapp.com/api/v4/activities/bookActivityCalendar.php"
+        data = {
+            **self.mandatory_params,
+            "id_activity_calendar": session_id,
+            "id_user": self.auth_handler.user_id,
+            "action_by": self.auth_handler.user_id,
+            "n_guests": "0",
+            "booked_on": "1",
+            "device_type": self.mandatory_params["device_type"],
+            "token": self.auth_handler.auth_token
+        }
+
+        for retry in range(3):
+            try:
+                response = self.session.post(
+                    url,
+                    headers=self.get_auth_headers(),
+                    data=data,
+                    timeout=10
+                )
+
+                if response.status_code == 200:
+                    json_response = response.json()
+                    if json_response.get("success", False):
+                        logging.info(f"Successfully booked session {session_id}")
+                        return True
+                    else:
+                        logging.error(f"API returned success:false: {json_response} - Session ID: {session_id}")
+                        return False
+
+                logging.error(f"HTTP {response.status_code}: {response.text[:100]}")
+                return False
+
+            except requests.exceptions.RequestException as e:
+                if retry == 2:
+                    logging.error(f"Final retry failed: {str(e)}")
+                    raise
+                wait_time = 1 * (2 ** retry)
+                logging.warning(f"Request failed (attempt {retry+1}/3): {str(e)}. Retrying in {wait_time}s...")
+                time.sleep(wait_time)
+
+        logging.error("Failed to complete request after 3 attempts")
+        return False
+
+    def get_booked_sessions(self) -> List[Dict[str, Any]]:
+        """
+        Get a list of booked sessions.
+
+        Returns:
+            A list of dictionaries containing information about the booked sessions.
+        """
+        url = "https://sport.nubapp.com/api/v4/activities/getBookedActivities.php"
+        data = {
+            **self.mandatory_params,
+            "id_user": self.auth_handler.user_id,
+            "action_by": self.auth_handler.user_id
+        }
+
+        for retry in range(3):
+            try:
+                response = self.session.post(
+                    url,
+                    headers=self.get_auth_headers(),
+                    data=data,
+                    timeout=10
+                )
+
+                if response.status_code == 200:
+                    json_response = response.json()
+                    if json_response.get("success", False):
+                        return json_response.get("data", [])
+                    logging.error(f"API returned success:false: {json_response}")
+                    return []
+
+                logging.error(f"HTTP {response.status_code}: {response.text[:100]}")
+                return []
+
+            except requests.exceptions.RequestException as e:
+                if retry == 2:
+                    logging.error(f"Final retry failed: {str(e)}")
+                    raise
+                wait_time = 1 * (2 ** retry)
+                logging.warning(f"Request failed (attempt {retry+1}/3): {str(e)}. Retrying in {wait_time}s...")
+                time.sleep(wait_time)
+
+        logging.error("Failed to complete request after 3 attempts")
+        return []
+
+    def is_session_bookable(self, session: Dict[str, Any], current_time: datetime) -> bool:
+        """
+        Check if a session is bookable based on user_info.
+
+        Args:
+            session (Dict[str, Any]): Session data.
+            current_time (datetime): Current time for comparison.
+
+        Returns:
+            bool: True if the session is bookable, False otherwise.
+        """
+        user_info = session.get("user_info", {})
+
+        # First check if can_join is true (primary condition)
+        if user_info.get("can_join", False):
+            return True
+
+        # Check if booking window is in the past
+        unable_to_book_until_date = user_info.get("unableToBookUntilDate", "")
+        unable_to_book_until_time = user_info.get("unableToBookUntilTime", "")
+
+        if unable_to_book_until_date and unable_to_book_until_time:
+            try:
+                # Parse the date and time
+                booking_window_time_str = f"{unable_to_book_until_date} {unable_to_book_until_time}"
+                booking_window_time = parse(booking_window_time_str)
+                if not booking_window_time.tzinfo:
+                    booking_window_time = pytz.timezone("Europe/Paris").localize(booking_window_time)
+
+                # If current time is after the booking window, session is bookable
+                if current_time > booking_window_time:
+                    return True
+            except (ValueError, TypeError):
+                # If parsing fails, default to not bookable
+                pass
+
+        # Default case: not bookable
+        return False
+
+    def matches_preferred_session(self, session: Dict[str, Any], current_time: datetime) -> bool:
+        """
+        Check if session matches one of your preferred sessions with exact matching.
+
+        Args:
+            session (Dict[str, Any]): Session data.
+            current_time (datetime): Current time for comparison.
+
+        Returns:
+            bool: True if the session matches a preferred session, False otherwise.
+        """
+        try:
+            session_time = parse(session["start_timestamp"])
+            if not session_time.tzinfo:
+                session_time = pytz.timezone("Europe/Paris").localize(session_time)
+
+            day_of_week = session_time.weekday()
+            session_time_str = session_time.strftime("%H:%M")
+            session_name = session.get("name_activity", "").upper()
+
+            for preferred_day, preferred_time, preferred_name in PREFERRED_SESSIONS:
+                # Exact match
+                if (day_of_week == preferred_day and
+                    session_time_str == preferred_time and
+                    preferred_name in session_name):
+                    return True
+
+            return False
+
+        except Exception as e:
+            logging.error(f"Failed to check session: {str(e)} - Session: {session}")
+            return False
+
+    def display_upcoming_sessions(self, sessions: List[Dict[str, Any]], current_time: datetime) -> None:
+        """
+        Display upcoming sessions with ID, name, date, and time.
+
+        Args:
+            sessions (List[Dict[str, Any]]): List of session data.
+            current_time (datetime): Current time for comparison.
+        """
+        if not sessions:
+            logging.info("No sessions to display")
+            return
+
+        logging.info("Upcoming sessions:")
+        logging.info("ID\t\tName\t\tDate\t\tTime")
+        logging.info("="*50)
+
+        for session in sessions:
+            session_time = parse(session["start_timestamp"])
+            if not session_time.tzinfo:
+                session_time = pytz.timezone("Europe/Paris").localize(session_time)
+
+            # Format session details
+            session_id = session.get("id_activity_calendar", "N/A")
+            session_name = session.get("name_activity", "N/A")
+            session_date = session_time.strftime("%Y-%m-%d")
+            session_time_str = session_time.strftime("%H:%M")
+
+            # Display session details
+            logging.info(f"{session_id}\t{session_name}\t{session_date}\t{session_time_str}")

src/session_notifier.py

@@ -1,8 +1,10 @@
 import smtplib
 import os
 import logging
+import asyncio
 from email.message import EmailMessage
 from telegram import Bot
+from telegram.error import TimedOut, NetworkError
 
 
 class SessionNotifier:
@@ -37,6 +39,9 @@ class SessionNotifier:
         # Check environment variable for impossible booking notifications
         self.notify_impossible = os.environ.get("NOTIFY_IMPOSSIBLE_BOOKING", "true").lower() in ("true", "1", "yes")
 
+        # Get crossfit username from environment
+        self.crossfit_username = os.environ.get("CROSSFIT_USERNAME", "User")
+
     def send_email_notification(self, message):
         """
         Send an email notification with the given message.
@@ -75,17 +80,34 @@ class SessionNotifier:
             logging.error(f"Failed to send email: {str(e)}")
             raise
 
-    async def send_telegram_notification(self, message):
+    async def send_telegram_notification(self, message, max_retries=3):
         """
         Send a Telegram notification with the given message.
 
         Args:
             message (str): The message content to be sent in the Telegram chat
+            max_retries (int): Maximum number of retry attempts (default: 3)
         """
         # Create a Bot instance with the provided token
         bot = Bot(token=self.telegram_credentials["token"])
-        # Send the message to the specified chat ID and await the result
-        await bot.send_message(chat_id=self.telegram_credentials["chat_id"], text=message)
+
+        for attempt in range(max_retries):
+            try:
+                # Send the message to the specified chat ID and await the result
+                await bot.send_message(chat_id=self.telegram_credentials["chat_id"], text=message)
+                logging.debug("Telegram notification sent successfully")
+                return
+            except (TimedOut, NetworkError) as e:
+                if attempt < max_retries - 1:
+                    wait_time = 2 ** attempt  # Exponential backoff: 1s, 2s, 4s
+                    logging.warning(f"Telegram notification failed (attempt {attempt + 1}/{max_retries}): {str(e)}. Retrying in {wait_time} seconds...")
+                    await asyncio.sleep(wait_time)
+                else:
+                    logging.error(f"Failed to send Telegram notification after {max_retries} attempts: {str(e)}")
+                    raise
+            except Exception as e:
+                logging.error(f"Unexpected error sending Telegram notification: {str(e)}")
+                raise
 
     async def notify_session_booking(self, session_details):
         """
@@ -95,8 +117,8 @@ class SessionNotifier:
             session_details (str): Details about the booked session
         """
         # Create messages for both email and Telegram
-        email_message = f"Session booked: {session_details}"
-        telegram_message = f"Session booked: {session_details}"
+        email_message = f"Session booked for {self.crossfit_username}: {session_details}"
+        telegram_message = f"Session booked for {self.crossfit_username}: {session_details}"
 
         # Send notifications through enabled channels
         if self.enable_email:
@@ -114,8 +136,8 @@ class SessionNotifier:
             days_until (int): Number of days until the session
         """
         # Create messages for both email and Telegram
-        email_message = f"Session available soon: {session_details} (in {days_until} days)"
-        telegram_message = f"Session available soon: {session_details} (in {days_until} days)"
+        email_message = f"Session available soon for {self.crossfit_username}: {session_details} (in {days_until} days)"
+        telegram_message = f"Session available soon for {self.crossfit_username}: {session_details} (in {days_until} days)"
 
         # Send notifications through enabled channels
         if self.enable_email:
@@ -145,8 +167,8 @@ class SessionNotifier:
             return
 
         # Create messages for both email and Telegram
-        email_message = f"Failed to book session: {session_details}"
-        telegram_message = f"Failed to book session: {session_details}"
+        email_message = f"Failed to book session for {self.crossfit_username}: {session_details}"
+        telegram_message = f"Failed to book session for {self.crossfit_username}: {session_details}"
 
         # Send notifications through enabled channels
         if self.enable_email:

test/test_auth.py

@@ -0,0 +1,135 @@
+#!/usr/bin/env python3
+"""
+Unit tests for AuthHandler class
+"""
+
+import pytest
+import os
+import sys
+import requests
+from unittest.mock import patch, Mock
+
+# Add the parent directory to the path
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from src.auth import AuthHandler
+
+class TestAuthHandlerAuthHeaders:
+    """Test cases for get_auth_headers method"""
+
+    def test_get_auth_headers_without_token(self):
+        """Test headers without auth token"""
+        auth_handler = AuthHandler('test_user', 'test_pass')
+        headers = auth_handler.get_auth_headers()
+        assert "Authorization" not in headers
+        assert headers["User-Agent"] == "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:140.0) Gecko/20100101 Firefox/140.0"
+
+    def test_get_auth_headers_with_token(self):
+        """Test headers with auth token"""
+        auth_handler = AuthHandler('test_user', 'test_pass')
+        auth_handler.auth_token = "test_token_123"
+        headers = auth_handler.get_auth_headers()
+        assert headers["Authorization"] == "Bearer test_token_123"
+
+class TestAuthHandlerLogin:
+    """Test cases for login method"""
+
+    @patch('requests.Session.post')
+    def test_login_success(self, mock_post):
+        """Test successful login flow"""
+        # Mock first login response
+        mock_response1 = Mock()
+        mock_response1.ok = True
+        mock_response1.json.return_value = {
+            "data": {
+                "user": {
+                    "id_user": "12345"
+                }
+            }
+        }
+
+        # Mock second login response
+        mock_response2 = Mock()
+        mock_response2.ok = True
+        mock_response2.json.return_value = {
+            "token": "test_bearer_token"
+        }
+
+        mock_post.side_effect = [mock_response1, mock_response2]
+
+        auth_handler = AuthHandler('test_user', 'test_pass')
+        result = auth_handler.login()
+
+        assert result is True
+        assert auth_handler.user_id == "12345"
+        assert auth_handler.auth_token == "test_bearer_token"
+
+    @patch('requests.Session.post')
+    def test_login_first_step_failure(self, mock_post):
+        """Test login failure on first step"""
+        mock_response = Mock()
+        mock_response.ok = False
+        mock_response.status_code = 400
+        mock_response.text = "Bad Request"
+
+        mock_post.return_value = mock_response
+
+        auth_handler = AuthHandler('test_user', 'test_pass')
+        result = auth_handler.login()
+
+        assert result is False
+        assert auth_handler.user_id is None
+        assert auth_handler.auth_token is None
+
+    @patch('requests.Session.post')
+    def test_login_second_step_failure(self, mock_post):
+        """Test login failure on second step"""
+        # First response succeeds
+        mock_response1 = Mock()
+        mock_response1.ok = True
+        mock_response1.json.return_value = {
+            "data": {
+                "user": {
+                    "id_user": "12345"
+                }
+            }
+        }
+
+        # Second response fails
+        mock_response2 = Mock()
+        mock_response2.ok = False
+        mock_response2.status_code = 401
+
+        mock_post.side_effect = [mock_response1, mock_response2]
+
+        auth_handler = AuthHandler('test_user', 'test_pass')
+        result = auth_handler.login()
+
+        assert result is False
+
+    @patch('requests.Session.post')
+    def test_login_json_parsing_error(self, mock_post):
+        """Test login with JSON parsing error"""
+        mock_response = Mock()
+        mock_response.ok = True
+        mock_response.json.side_effect = ValueError("Invalid JSON")
+
+        mock_post.return_value = mock_response
+
+        auth_handler = AuthHandler('test_user', 'test_pass')
+        result = auth_handler.login()
+
+        assert result is False
+
+    @patch('requests.Session.post')
+    def test_login_request_exception(self, mock_post):
+        """Test login with request exception"""
+        mock_post.side_effect = requests.exceptions.ConnectionError("Network error")
+
+        auth_handler = AuthHandler('test_user', 'test_pass')
+        result = auth_handler.login()
+
+        assert result is False
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])

test/test_crossfit_booker.py

@@ -1,209 +0,0 @@
-#!/usr/bin/env python3
-"""
-Test script for the refactored CrossFitBooker functional implementation.
-"""
-
-import sys
-import os
-from datetime import datetime
-import pytz
-from typing import List, Dict, Any, Tuple
-
-# Add the current directory to the path so we can import our modules
-sys.path.append(os.path.dirname(os.path.abspath(__file__)))
-
-# Import the functional functions from our refactored code
-# Import the functional functions from our refactored code
-import sys
-import os
-sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
-from crossfit_booker_functional import (
-    is_session_bookable,
-    matches_preferred_session,
-    filter_bookable_sessions,
-    filter_upcoming_sessions,
-    filter_preferred_sessions,
-    categorize_sessions,
-    format_session_details
-)
-
-def test_is_session_bookable():
-    """Test the is_session_bookable function."""
-    print("Testing is_session_bookable...")
-    
-    # Test case 1: Session with can_join = True
-    session1 = {
-        "user_info": {
-            "can_join": True
-        }
-    }
-    current_time = datetime.now(pytz.timezone("Europe/Paris"))
-    assert is_session_bookable(session1, current_time, "Europe/Paris") == True
-    
-    # Test case 2: Session with booking window in the past
-    session2 = {
-        "user_info": {
-            "unableToBookUntilDate": "01-01-2020",
-            "unableToBookUntilTime": "10:00"
-        }
-    }
-    assert is_session_bookable(session2, current_time, "Europe/Paris") == True
-    
-    # Test case 3: Session with booking window in the future
-    session3 = {
-        "user_info": {
-            "unableToBookUntilDate": "01-01-2030",
-            "unableToBookUntilTime": "10:00"
-        }
-    }
-    assert is_session_bookable(session3, current_time, "Europe/Paris") == False
-    
-    print("✓ is_session_bookable tests passed")
-
-
-def test_matches_preferred_session():
-    """Test the matches_preferred_session function."""
-    print("Testing matches_preferred_session...")
-    
-    # Define some preferred sessions (day_of_week, start_time, session_name_contains)
-    preferred_sessions: List[Tuple[int, str, str]] = [
-        (2, "18:30", "CONDITIONING"),   # Wednesday 18:30 CONDITIONING
-        (4, "17:00", "WEIGHTLIFTING"),  # Friday 17:00 WEIGHTLIFTING
-        (5, "12:30", "HYROX"),          # Saturday 12:30 HYROX
-    ]
-    
-    # Test case 1: Exact match
-    session1 = {
-        "start_timestamp": "2025-07-30 18:30:00",  # Wednesday
-        "name_activity": "CONDITIONING"
-    }
-    assert matches_preferred_session(session1, preferred_sessions, "Europe/Paris") == True
-    
-    # Test case 2: No match
-    session2 = {
-        "start_timestamp": "2025-07-30 18:30:00",  # Wednesday
-        "name_activity": "YOGA"
-    }
-    assert matches_preferred_session(session2, preferred_sessions, "Europe/Paris") == False
-    
-    print("✓ matches_preferred_session tests passed")
-
-
-def test_filter_functions():
-    """Test the filter functions."""
-    print("Testing filter functions...")
-    
-    # Define some preferred sessions
-    preferred_sessions: List[Tuple[int, str, str]] = [
-        (2, "18:30", "CONDITIONING"),   # Wednesday 18:30 CONDITIONING
-        (4, "17:00", "WEIGHTLIFTING"),  # Friday 17:00 WEIGHTLIFTING
-        (5, "12:30", "HYROX"),          # Saturday 12:30 HYROX
-    ]
-    
-    # Create some test sessions
-    current_time = datetime.now(pytz.timezone("Europe/Paris"))
-    
-    sessions = [
-        {
-            "start_timestamp": "2025-07-30 18:30:00",  # Wednesday
-            "name_activity": "CONDITIONING",
-            "user_info": {"can_join": True}
-        },
-        {
-            "start_timestamp": "2025-07-30 19:00:00",  # Wednesday
-            "name_activity": "YOGA",
-            "user_info": {"can_join": True}
-        },
-        {
-            "start_timestamp": "2025-08-01 17:00:00",  # Friday
-            "name_activity": "WEIGHTLIFTING",
-            "user_info": {"can_join": True}
-        }
-    ]
-    
-    # Test filter_preferred_sessions
-    preferred = filter_preferred_sessions(sessions, preferred_sessions, "Europe/Paris")
-    assert len(preferred) == 2  # CONDITIONING and WEIGHTLIFTING sessions
-    
-    # Test filter_bookable_sessions
-    bookable = filter_bookable_sessions(sessions, current_time, preferred_sessions, "Europe/Paris")
-    assert len(bookable) == 2  # Both preferred sessions are bookable
-    
-    print("✓ Filter function tests passed")
-
-
-def test_categorize_sessions():
-    """Test the categorize_sessions function."""
-    print("Testing categorize_sessions...")
-    
-    # Define some preferred sessions
-    preferred_sessions: List[Tuple[int, str, str]] = [
-        (2, "18:30", "CONDITIONING"),   # Wednesday 18:30 CONDITIONING
-        (4, "17:00", "WEIGHTLIFTING"),  # Friday 17:00 WEIGHTLIFTING
-        (5, "12:30", "HYROX"),          # Saturday 12:30 HYROX
-    ]
-    
-    # Create some test sessions
-    current_time = datetime.now(pytz.timezone("Europe/Paris"))
-    
-    sessions = [
-        {
-            "start_timestamp": "2025-07-30 18:30:00",  # Wednesday
-            "name_activity": "CONDITIONING",
-            "user_info": {"can_join": True}
-        },
-        {
-            "start_timestamp": "2025-07-31 18:30:00",  # Thursday (tomorrow relative to Wednesday)
-            "name_activity": "CONDITIONING",
-            "user_info": {"can_join": False, "unableToBookUntilDate": "01-08-2025", "unableToBookUntilTime": "10:00"}
-        }
-    ]
-    
-    # Test categorize_sessions
-    categorized = categorize_sessions(sessions, current_time, preferred_sessions, "Europe/Paris")
-    assert "bookable" in categorized
-    assert "upcoming" in categorized
-    assert "all_preferred" in categorized
-    
-    print("✓ categorize_sessions tests passed")
-
-
-def test_format_session_details():
-    """Test the format_session_details function."""
-    print("Testing format_session_details...")
-    
-    # Test case 1: Valid session
-    session1 = {
-        "start_timestamp": "2025-07-30 18:30:00",
-        "name_activity": "CONDITIONING"
-    }
-    formatted = format_session_details(session1, "Europe/Paris")
-    assert "CONDITIONING" in formatted
-    assert "2025-07-30 18:30" in formatted
-    
-    # Test case 2: Session with missing data
-    session2 = {
-        "name_activity": "WEIGHTLIFTING"
-    }
-    formatted = format_session_details(session2, "Europe/Paris")
-    assert "WEIGHTLIFTING" in formatted
-    assert "Unknown time" in formatted
-    
-    print("✓ format_session_details tests passed")
-
-
-def run_all_tests():
-    """Run all tests."""
-    print("Running all tests for CrossFitBooker functional implementation...\n")
-    
-    test_is_session_bookable()
-    test_matches_preferred_session()
-    test_filter_functions()
-    test_categorize_sessions()
-    test_format_session_details()
-    
-    print("\n✓ All tests passed!")
-
-
-if __name__ == "__main__":
-    run_all_tests()

test/test_crossfit_booker_auth.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 """
-Unit tests for CrossFitBooker authentication methods
+Unit tests for CrossFitBooker authentication methods using AuthHandler
 """
 
 import pytest
@@ -12,38 +12,38 @@ from unittest.mock import patch, Mock
 # Add the parent directory to the path
 sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 
-from crossfit_booker import CrossFitBooker
-
+from src.auth import AuthHandler
+from src.booker import Booker
+from src.session_notifier import SessionNotifier
 
 class TestCrossFitBookerAuthHeaders:
     """Test cases for get_auth_headers method"""
-    
+
     def test_get_auth_headers_without_token(self):
         """Test headers without auth token"""
         with patch.dict(os.environ, {
             'CROSSFIT_USERNAME': 'test_user',
             'CROSSFIT_PASSWORD': 'test_pass'
         }):
-            booker = CrossFitBooker()
-            headers = booker.get_auth_headers()
+            auth_handler = AuthHandler('test_user', 'test_pass')
+            headers = auth_handler.get_auth_headers()
             assert "Authorization" not in headers
             assert headers["User-Agent"] == "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:140.0) Gecko/20100101 Firefox/140.0"
-    
+
     def test_get_auth_headers_with_token(self):
         """Test headers with auth token"""
         with patch.dict(os.environ, {
             'CROSSFIT_USERNAME': 'test_user',
             'CROSSFIT_PASSWORD': 'test_pass'
         }):
-            booker = CrossFitBooker()
-            booker.auth_token = "test_token_123"
-            headers = booker.get_auth_headers()
+            auth_handler = AuthHandler('test_user', 'test_pass')
+            auth_handler.auth_token = "test_token_123"
+            headers = auth_handler.get_auth_headers()
             assert headers["Authorization"] == "Bearer test_token_123"
 
+class TestAuthHandlerLogin:
+    """Test cases for AuthHandler login method"""
 
-class TestCrossFitBookerLogin:
-    """Test cases for login method"""
-    
     @patch('requests.Session.post')
     def test_login_success(self, mock_post):
         """Test successful login flow"""
@@ -57,27 +57,27 @@ class TestCrossFitBookerLogin:
                 }
             }
         }
-        
+
         # Mock second login response
         mock_response2 = Mock()
         mock_response2.ok = True
         mock_response2.json.return_value = {
             "token": "test_bearer_token"
         }
-        
+
         mock_post.side_effect = [mock_response1, mock_response2]
-        
+
         with patch.dict(os.environ, {
             'CROSSFIT_USERNAME': 'test_user',
             'CROSSFIT_PASSWORD': 'test_pass'
         }):
-            booker = CrossFitBooker()
-            result = booker.login()
-            
+            auth_handler = AuthHandler('test_user', 'test_pass')
+            result = auth_handler.login()
+
             assert result is True
-            assert booker.user_id == "12345"
-            assert booker.auth_token == "test_bearer_token"
-    
+            assert auth_handler.user_id == "12345"
+            assert auth_handler.auth_token == "test_bearer_token"
+
     @patch('requests.Session.post')
     def test_login_first_step_failure(self, mock_post):
         """Test login failure on first step"""
@@ -85,20 +85,20 @@ class TestCrossFitBookerLogin:
         mock_response.ok = False
         mock_response.status_code = 400
         mock_response.text = "Bad Request"
-        
+
         mock_post.return_value = mock_response
-        
+
         with patch.dict(os.environ, {
             'CROSSFIT_USERNAME': 'test_user',
             'CROSSFIT_PASSWORD': 'test_pass'
         }):
-            booker = CrossFitBooker()
-            result = booker.login()
-            
+            auth_handler = AuthHandler('test_user', 'test_pass')
+            result = auth_handler.login()
+
             assert result is False
-            assert booker.user_id is None
-            assert booker.auth_token is None
-    
+            assert auth_handler.user_id is None
+            assert auth_handler.auth_token is None
+
     @patch('requests.Session.post')
     def test_login_second_step_failure(self, mock_post):
         """Test login failure on second step"""
@@ -112,55 +112,54 @@ class TestCrossFitBookerLogin:
                 }
             }
         }
-        
+
         # Second response fails
         mock_response2 = Mock()
         mock_response2.ok = False
         mock_response2.status_code = 401
-        
+
         mock_post.side_effect = [mock_response1, mock_response2]
-        
+
         with patch.dict(os.environ, {
             'CROSSFIT_USERNAME': 'test_user',
             'CROSSFIT_PASSWORD': 'test_pass'
         }):
-            booker = CrossFitBooker()
-            result = booker.login()
-            
+            auth_handler = AuthHandler('test_user', 'test_pass')
+            result = auth_handler.login()
+
             assert result is False
-    
+
     @patch('requests.Session.post')
     def test_login_json_parsing_error(self, mock_post):
         """Test login with JSON parsing error"""
         mock_response = Mock()
         mock_response.ok = True
         mock_response.json.side_effect = ValueError("Invalid JSON")
-        
+
         mock_post.return_value = mock_response
-        
+
         with patch.dict(os.environ, {
             'CROSSFIT_USERNAME': 'test_user',
             'CROSSFIT_PASSWORD': 'test_pass'
         }):
-            booker = CrossFitBooker()
-            result = booker.login()
-            
+            auth_handler = AuthHandler('test_user', 'test_pass')
+            result = auth_handler.login()
+
             assert result is False
-    
+
     @patch('requests.Session.post')
     def test_login_request_exception(self, mock_post):
         """Test login with request exception"""
         mock_post.side_effect = requests.exceptions.ConnectionError("Network error")
-        
+
         with patch.dict(os.environ, {
             'CROSSFIT_USERNAME': 'test_user',
             'CROSSFIT_PASSWORD': 'test_pass'
         }):
-            booker = CrossFitBooker()
-            result = booker.login()
-            
-            assert result is False
+            auth_handler = AuthHandler('test_user', 'test_pass')
+            result = auth_handler.login()
 
+            assert result is False
 
 if __name__ == "__main__":
     pytest.main([__file__, "-v"])

test/test_crossfit_booker_final.py

@@ -1,239 +0,0 @@
-#!/usr/bin/env python3
-"""
-Comprehensive unit tests for the CrossFitBooker class in crossfit_booker.py
-"""
-
-import pytest
-import os
-import sys
-from unittest.mock import Mock, patch, MagicMock, AsyncMock
-from datetime import datetime, date, timedelta
-import pytz
-import requests
-from typing import Dict, Any, List
-
-# Add the parent directory to the path to import crossfit_booker
-sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-
-from crossfit_booker import CrossFitBooker
-
-
-class TestCrossFitBookerInit:
-    """Test cases for CrossFitBooker initialization"""
-    
-    def test_init_success(self):
-        """Test successful initialization with all required env vars"""
-        with patch.dict(os.environ, {
-            'CROSSFIT_USERNAME': 'test_user',
-            'CROSSFIT_PASSWORD': 'test_pass',
-            'EMAIL_FROM': 'from@test.com',
-            'EMAIL_TO': 'to@test.com',
-            'EMAIL_PASSWORD': 'email_pass',
-            'TELEGRAM_TOKEN': 'telegram_token',
-            'TELEGRAM_CHAT_ID': '12345'
-        }):
-            booker = CrossFitBooker()
-            assert booker.auth_token is None
-            assert booker.user_id is None
-            assert booker.session is not None
-            assert booker.notifier is not None
-    
-    def test_init_missing_credentials(self):
-        """Test initialization fails with missing credentials"""
-        with patch.dict(os.environ, {}, clear=True):
-            try:
-                CrossFitBooker()
-            except ValueError as e:
-                assert str(e) == "Missing environment variables"
-    
-    def test_init_partial_credentials(self):
-        """Test initialization fails with partial credentials"""
-        with patch.dict(os.environ, {
-            'CROSSFIT_USERNAME': 'test_user'
-            # Missing PASSWORD
-        }, clear=True):
-            try:
-                CrossFitBooker()
-            except ValueError as e:
-                assert str(e) == "Missing environment variables"
-
-
-class TestCrossFitBookerAuthHeaders:
-    """Test cases for get_auth_headers method"""
-    
-    def test_get_auth_headers_without_token(self):
-        """Test headers without auth token"""
-        with patch.dict(os.environ, {
-            'CROSSFIT_USERNAME': 'test_user',
-            'CROSSFIT_PASSWORD': 'test_pass'
-        }):
-            booker = CrossFitBooker()
-            headers = booker.get_auth_headers()
-            assert "Authorization" not in headers
-            assert headers["User-Agent"] == "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:140.0) Gecko/20100101 Firefox/140.0"
-    
-    def test_get_auth_headers_with_token(self):
-        """Test headers with auth token"""
-        with patch.dict(os.environ, {
-            'CROSSFIT_USERNAME': 'test_user',
-            'CROSSFIT_PASSWORD': 'test_pass'
-        }):
-            booker = CrossFitBooker()
-            booker.auth_token = "test_token_123"
-            headers = booker.get_auth_headers()
-            assert headers["Authorization"] == "Bearer test_token_123"
-
-
-class TestCrossFitBookerLogin:
-    """Test cases for login method"""
-    
-    @patch('requests.Session.post')
-    def test_login_success(self, mock_post):
-        """Test successful login flow"""
-        # Mock first login response
-        mock_response1 = Mock()
-        mock_response1.ok = True
-        mock_response1.json.return_value = {
-            "data": {
-                "user": {
-                    "id_user": "12345"
-                }
-            }
-        }
-        
-        # Mock second login response
-        mock_response2 = Mock()
-        mock_response2.ok = True
-        mock_response2.json.return_value = {
-            "token": "test_bearer_token"
-        }
-        
-        mock_post.side_effect = [mock_response1, mock_response2]
-        
-        with patch.dict(os.environ, {
-            'CROSSFIT_USERNAME': 'test_user',
-            'CROSSFIT_PASSWORD': 'test_pass'
-        }):
-            booker = CrossFitBooker()
-            result = booker.login()
-            
-            assert result is True
-            assert booker.user_id == "12345"
-            assert booker.auth_token == "test_bearer_token"
-    
-    @patch('requests.Session.post')
-    def test_login_first_step_failure(self, mock_post):
-        """Test login failure on first step"""
-        mock_response = Mock()
-        mock_response.ok = False
-        mock_response.status_code = 400
-        mock_response.text = "Bad Request"
-        
-        mock_post.return_value = mock_response
-        
-        with patch.dict(os.environ, {
-            'CROSSFIT_USERNAME': 'test_user',
-            'CROSSFIT_PASSWORD': 'test_pass'
-        }):
-            booker = CrossFitBooker()
-            result = booker.login()
-            
-            assert result is False
-            assert booker.user_id is None
-            assert booker.auth_token is None
-    
-    @patch('requests.Session.post')
-    def test_login_json_parsing_error(self, mock_post):
-        """Test login with JSON parsing error"""
-        mock_response = Mock()
-        mock_response.ok = True
-        mock_response.json.side_effect = ValueError("Invalid JSON")
-        
-        mock_post.return_value = mock_response
-        
-        with patch.dict(os.environ, {
-            'CROSSFIT_USERNAME': 'test_user',
-            'CROSSFIT_PASSWORD': 'test_pass'
-        }):
-            booker = CrossFitBooker()
-            result = booker.login()
-            
-            assert result is False
-    
-    @patch('requests.Session.post')
-    def test_login_request_exception(self, mock_post):
-        """Test login with request exception"""
-        mock_post.side_effect = requests.exceptions.ConnectionError("Network error")
-        
-        with patch.dict(os.environ, {
-            'CROSSFIT_USERNAME': 'test_user',
-            'CROSSFIT_PASSWORD': 'test_pass'
-        }):
-            booker = CrossFitBooker()
-            result = booker.login()
-            
-            assert result is False
-
-
-class TestCrossFitBookerGetAvailableSessions:
-    """Test cases for get_available_sessions method"""
-    
-    def test_get_available_sessions_no_auth(self):
-        """Test get_available_sessions without authentication"""
-        with patch.dict(os.environ, {
-            'CROSSFIT_USERNAME': 'test_user',
-            'CROSSFIT_PASSWORD': 'test_pass'
-        }):
-            booker = CrossFitBooker()
-            result = booker.get_available_sessions(date(2025, 7, 24), date(2025, 7, 25))
-            assert result is None
-    
-    @patch('requests.Session.post')
-    def test_get_available_sessions_success(self, mock_post):
-        """Test successful get_available_sessions"""
-        mock_response = Mock()
-        mock_response.status_code = 200
-        mock_response.json.return_value = {
-            "success": True,
-            "data": {
-                "activities_calendar": [
-                    {"id": "1", "name": "Test Session"}
-                ]
-            }
-        }
-        
-        mock_post.return_value = mock_response
-        
-        with patch.dict(os.environ, {
-            'CROSSFIT_USERNAME': 'test_user',
-            'CROSSFIT_PASSWORD': 'test_pass'
-        }):
-            booker = CrossFitBooker()
-            booker.auth_token = "test_token"
-            booker.user_id = "12345"
-            
-            result = booker.get_available_sessions(date(2025, 7, 24), date(2025, 7, 25))
-            
-            assert result is not None
-            assert result["success"] is True
-    
-    @patch('requests.Session.post')
-    def test_get_available_sessions_failure(self, mock_post):
-        """Test get_available_sessions with API failure"""
-        mock_response = Mock()
-        mock_response.status_code = 400
-        mock_response.text = "Bad Request"
-        
-        mock_post.return_value = mock_response
-        
-        with patch.dict(os.environ, {
-            'CROSSFIT_USERNAME': 'test_user',
-            'CROSSFIT_PASSWORD': 'test_pass'
-        }):
-            booker = CrossFitBooker()
-            booker.auth_token = "test_token"
-            booker.user_id = "12345"
-            
-            result = booker.get_available_sessions(date(2025, 7, 24), date(2025, 7, 25))
-            
-            assert result is None

test/test_crossfit_booker_functional.py

@@ -1,293 +0,0 @@
-#!/usr/bin/env python3
-"""
-Unit tests for CrossFitBooker functional methods
-"""
-
-import pytest
-import os
-import sys
-from unittest.mock import patch, Mock
-from datetime import datetime, date, timedelta
-import pytz
-from typing import List, Dict, Any, Tuple
-
-# Add the parent directory to the path
-sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-
-from crossfit_booker_functional import (
-    get_auth_headers,
-    is_session_bookable,
-    matches_preferred_session,
-    prepare_booking_data,
-    is_bookable_and_preferred,
-    filter_bookable_sessions,
-    is_upcoming_preferred,
-    filter_upcoming_sessions,
-    filter_preferred_sessions,
-    format_session_details,
-    categorize_sessions,
-    process_booking_results
-)
-
-# Mock preferred sessions
-MOCK_PREFERRED_SESSIONS = [
-    (2, "18:30", "CONDITIONING"),  # Wednesday 18:30 CONDITIONING
-    (4, "17:00", "WEIGHTLIFTING"),  # Friday 17:00 WEIGHTLIFTING
-    (5, "12:30", "HYROX"),         # Saturday 12:30 HYROX
-]
-
-class TestCrossFitBookerFunctional:
-    """Test cases for CrossFitBooker functional methods"""
-
-    def test_get_auth_headers_without_token(self):
-        """Test headers without auth token"""
-        base_headers = {"User-Agent": "test-agent"}
-        headers = get_auth_headers(base_headers, None)
-        assert "Authorization" not in headers
-        assert headers["User-Agent"] == "test-agent"
-
-    def test_get_auth_headers_with_token(self):
-        """Test headers with auth token"""
-        base_headers = {"User-Agent": "test-agent"}
-        headers = get_auth_headers(base_headers, "test_token_123")
-        assert headers["Authorization"] == "Bearer test_token_123"
-        assert headers["User-Agent"] == "test-agent"
-
-    def test_is_session_bookable_can_join_true(self):
-        """Test session bookable with can_join=True"""
-        session = {"user_info": {"can_join": True}}
-        current_time = datetime.now(pytz.timezone("Europe/Paris"))
-        assert is_session_bookable(session, current_time, "Europe/Paris") is True
-
-    def test_is_session_bookable_booking_window_past(self):
-        """Test session bookable with booking window in past"""
-        session = {
-            "user_info": {
-                "can_join": False,
-                "unableToBookUntilDate": "01-01-2020",
-                "unableToBookUntilTime": "10:00"
-            }
-        }
-        current_time = datetime.now(pytz.timezone("Europe/Paris"))
-        assert is_session_bookable(session, current_time, "Europe/Paris") is True
-
-    def test_is_session_bookable_booking_window_future(self):
-        """Test session not bookable with booking window in future"""
-        session = {
-            "user_info": {
-                "can_join": False,
-                "unableToBookUntilDate": "01-01-2030",
-                "unableToBookUntilTime": "10:00"
-            }
-        }
-        current_time = datetime.now(pytz.timezone("Europe/Paris"))
-        assert is_session_bookable(session, current_time, "Europe/Paris") is False
-
-    def test_matches_preferred_session_exact_match(self):
-        """Test exact match with preferred session"""
-        session = {
-            "start_timestamp": "2025-07-30 18:30:00",
-            "name_activity": "CONDITIONING"
-        }
-        current_time = datetime(2025, 7, 30, 12, 0, 0, tzinfo=pytz.timezone("Europe/Paris"))
-
-        with patch('crossfit_booker_functional.PREFERRED_SESSIONS', MOCK_PREFERRED_SESSIONS):
-            assert matches_preferred_session(session, MOCK_PREFERRED_SESSIONS, "Europe/Paris") is True
-
-    def test_matches_preferred_session_fuzzy_match(self):
-        """Test fuzzy match with preferred session"""
-        session = {
-            "start_timestamp": "2025-07-30 18:30:00",
-            "name_activity": "CONDITIONING WORKOUT"
-        }
-        current_time = datetime(2025, 7, 30, 12, 0, 0, tzinfo=pytz.timezone("Europe/Paris"))
-
-        with patch('crossfit_booker_functional.PREFERRED_SESSIONS', MOCK_PREFERRED_SESSIONS):
-            assert matches_preferred_session(session, MOCK_PREFERRED_SESSIONS, "Europe/Paris") is True
-
-    def test_matches_preferred_session_no_match(self):
-        """Test no match with preferred session"""
-        session = {
-            "start_timestamp": "2025-07-30 18:30:00",
-            "name_activity": "YOGA"
-        }
-        current_time = datetime(2025, 7, 30, 12, 0, 0, tzinfo=pytz.timezone("Europe/Paris"))
-
-        with patch('crossfit_booker_functional.PREFERRED_SESSIONS', MOCK_PREFERRED_SESSIONS):
-            assert matches_preferred_session(session, MOCK_PREFERRED_SESSIONS, "Europe/Paris") is False
-
-    def test_prepare_booking_data(self):
-        """Test prepare_booking_data function"""
-        mandatory_params = {"app_version": "1.0", "device_type": "1"}
-        session_id = "session_123"
-        user_id = "user_456"
-
-        data = prepare_booking_data(mandatory_params, session_id, user_id)
-        assert data["id_activity_calendar"] == session_id
-        assert data["id_user"] == user_id
-        assert data["action_by"] == user_id
-        assert data["n_guests"] == "0"
-        assert data["booked_on"] == "3"
-        assert data["app_version"] == "1.0"
-        assert data["device_type"] == "1"
-
-    def test_is_bookable_and_preferred(self):
-        """Test is_bookable_and_preferred function"""
-        session = {
-            "start_timestamp": "2025-07-30 18:30:00",
-            "name_activity": "CONDITIONING",
-            "user_info": {"can_join": True}
-        }
-        current_time = datetime.now(pytz.timezone("Europe/Paris"))
-
-        with patch('crossfit_booker_functional.PREFERRED_SESSIONS', MOCK_PREFERRED_SESSIONS):
-            assert is_bookable_and_preferred(session, current_time, MOCK_PREFERRED_SESSIONS, "Europe/Paris") is True
-
-    def test_filter_bookable_sessions(self):
-        """Test filter_bookable_sessions function"""
-        current_time = datetime.now(pytz.timezone("Europe/Paris"))
-
-        # Create test sessions
-        sessions = [
-            {
-                "start_timestamp": "2025-07-30 18:30:00",  # Wednesday
-                "name_activity": "CONDITIONING",
-                "user_info": {"can_join": True}
-            },
-            {
-                "start_timestamp": "2025-07-31 18:30:00",  # Thursday
-                "name_activity": "YOGA",
-                "user_info": {"can_join": True}
-            }
-        ]
-
-        with patch('crossfit_booker_functional.PREFERRED_SESSIONS', MOCK_PREFERRED_SESSIONS):
-            bookable_sessions = filter_bookable_sessions(sessions, current_time, MOCK_PREFERRED_SESSIONS, "Europe/Paris")
-            assert len(bookable_sessions) == 1
-            assert bookable_sessions[0]["name_activity"] == "CONDITIONING"
-
-    def test_is_upcoming_preferred(self):
-        """Test is_upcoming_preferred function"""
-        # Test with a session that is tomorrow
-        session = {
-            "start_timestamp": "2025-07-31 18:30:00",  # Tomorrow
-            "name_activity": "CONDITIONING"
-        }
-        current_time = datetime(2025, 7, 30, 12, 0, 0, tzinfo=pytz.timezone("Europe/Paris"))
-
-        with patch('crossfit_booker_functional.PREFERRED_SESSIONS', MOCK_PREFERRED_SESSIONS):
-            assert is_upcoming_preferred(session, current_time, MOCK_PREFERRED_SESSIONS, "Europe/Paris") is True
-
-        # Test with a session that is today
-        session = {
-            "start_timestamp": "2025-07-30 18:30:00",  # Today
-            "name_activity": "CONDITIONING"
-        }
-        current_time = datetime(2025, 7, 30, 12, 0, 0, tzinfo=pytz.timezone("Europe/Paris"))
-
-        with patch('crossfit_booker_functional.PREFERRED_SESSIONS', MOCK_PREFERRED_SESSIONS):
-            assert is_upcoming_preferred(session, current_time, MOCK_PREFERRED_SESSIONS, "Europe/Paris") is False
-
-    def test_filter_upcoming_sessions(self):
-        """Test filter_upcoming_sessions function"""
-        current_time = datetime(2025, 7, 30, 12, 0, 0, tzinfo=pytz.timezone("Europe/Paris"))
-
-        # Create test sessions
-        sessions = [
-            {
-                "start_timestamp": "2025-07-30 18:30:00",  # Today
-                "name_activity": "CONDITIONING",
-                "user_info": {"can_join": True}
-            },
-            {
-                "start_timestamp": "2025-07-31 18:30:00",  # Tomorrow
-                "name_activity": "CONDITIONING",
-                "user_info": {"can_join": True}
-            }
-        ]
-
-        with patch('crossfit_booker_functional.PREFERRED_SESSIONS', MOCK_PREFERRED_SESSIONS):
-            upcoming_sessions = filter_upcoming_sessions(sessions, current_time, MOCK_PREFERRED_SESSIONS, "Europe/Paris")
-            assert len(upcoming_sessions) == 1
-            assert upcoming_sessions[0]["name_activity"] == "CONDITIONING"
-
-    def test_filter_preferred_sessions(self):
-        """Test filter_preferred_sessions function"""
-        # Create test sessions
-        sessions = [
-            {
-                "start_timestamp": "2025-07-30 18:30:00",
-                "name_activity": "CONDITIONING"
-            },
-            {
-                "start_timestamp": "2025-07-31 18:30:00",
-                "name_activity": "YOGA"
-            }
-        ]
-
-        with patch('crossfit_booker_functional.PREFERRED_SESSIONS', MOCK_PREFERRED_SESSIONS):
-            preferred_sessions = filter_preferred_sessions(sessions, MOCK_PREFERRED_SESSIONS, "Europe/Paris")
-            assert len(preferred_sessions) == 1
-            assert preferred_sessions[0]["name_activity"] == "CONDITIONING"
-
-    def test_format_session_details(self):
-        """Test format_session_details function"""
-        # Test with valid session
-        session = {
-            "start_timestamp": "2025-07-30 18:30:00",
-            "name_activity": "CONDITIONING"
-        }
-        formatted = format_session_details(session, "Europe/Paris")
-        assert "CONDITIONING" in formatted
-        assert "2025-07-30 18:30" in formatted
-
-        # Test with missing data
-        session = {
-            "name_activity": "WEIGHTLIFTING"
-        }
-        formatted = format_session_details(session, "Europe/Paris")
-        assert "WEIGHTLIFTING" in formatted
-        assert "Unknown time" in formatted
-
-    def test_categorize_sessions(self):
-        """Test categorize_sessions function"""
-        current_time = datetime(2025, 7, 30, 12, 0, 0, tzinfo=pytz.timezone("Europe/Paris"))
-
-        # Create test sessions
-        sessions = [
-            {
-                "start_timestamp": "2025-07-30 18:30:00",  # Today
-                "name_activity": "CONDITIONING",
-                "user_info": {"can_join": True}
-            },
-            {
-                "start_timestamp": "2025-07-31 18:30:00",  # Tomorrow
-                "name_activity": "CONDITIONING",
-                "user_info": {"can_join": True}
-            }
-        ]
-
-        with patch('crossfit_booker_functional.PREFERRED_SESSIONS', MOCK_PREFERRED_SESSIONS):
-            categorized = categorize_sessions(sessions, current_time, MOCK_PREFERRED_SESSIONS, "Europe/Paris")
-            assert "bookable" in categorized
-            assert "upcoming" in categorized
-            assert "all_preferred" in categorized
-            assert len(categorized["bookable"]) == 1
-            assert len(categorized["upcoming"]) == 1
-            assert len(categorized["all_preferred"]) == 1
-
-    def test_process_booking_results(self):
-        """Test process_booking_results function"""
-        session = {
-            "start_timestamp": "2025-07-30 18:30:00",
-            "name_activity": "CONDITIONING"
-        }
-
-        result = process_booking_results(session, True, "Europe/Paris")
-        assert result["session"] == session
-        assert result["success"] is True
-        assert "CONDITIONING" in result["details"]
-        assert "2025-07-30 18:30" in result["details"]
-
-if __name__ == "__main__":
-    pytest.main([__file__, "-v"])

test/test_crossfit_booker_init.py

@@ -1,19 +0,0 @@
-#!/usr/bin/env python3
-"""
-Unit tests for CrossFitBooker initialization
-"""
-
-import pytest
-import os
-import sys
-from unittest.mock import patch
-
-# Add the parent directory to the path
-sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-
-from crossfit_booker import CrossFitBooker
-
-
-
-if __name__ == "__main__":
-    pytest.main([__file__, "-v"])

test/test_crossfit_booker_sessions.py

@@ -6,30 +6,34 @@ Unit tests for CrossFitBooker session-related methods
 import pytest
 import os
 import sys
-from unittest.mock import patch, Mock, AsyncMock
-from datetime import datetime, date, timedelta
+from unittest.mock import patch, Mock
+from datetime import datetime, timedelta, date
 import pytz
-import asyncio
 
 # Add the parent directory to the path
 sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 
-from crossfit_booker import CrossFitBooker
+from src.auth import AuthHandler
+from src.booker import Booker
+from src.session_notifier import SessionNotifier
+from src.session_manager import SessionManager
+
 
 
 class TestCrossFitBookerGetAvailableSessions:
     """Test cases for get_available_sessions method"""
-    
+
     def test_get_available_sessions_no_auth(self):
         """Test get_available_sessions without authentication"""
         with patch.dict(os.environ, {
             'CROSSFIT_USERNAME': 'test_user',
             'CROSSFIT_PASSWORD': 'test_pass'
         }):
-            booker = CrossFitBooker()
-            result = booker.get_available_sessions(date(2025, 7, 24), date(2025, 7, 25))
+            auth_handler = AuthHandler('test_user', 'test_pass')
+            session_manager = SessionManager(auth_handler)
+            result = session_manager.get_available_sessions(date(2025, 7, 24), date(2025, 7, 25))
             assert result is None
-    
+
     @patch('requests.Session.post')
     def test_get_available_sessions_success(self, mock_post):
         """Test successful get_available_sessions"""
@@ -43,122 +47,127 @@ class TestCrossFitBookerGetAvailableSessions:
                 ]
             }
         }
-        
+
         mock_post.return_value = mock_response
-        
+
         with patch.dict(os.environ, {
             'CROSSFIT_USERNAME': 'test_user',
             'CROSSFIT_PASSWORD': 'test_pass'
         }):
-            booker = CrossFitBooker()
-            booker.auth_token = "test_token"
-            booker.user_id = "12345"
-            
-            result = booker.get_available_sessions(date(2025, 7, 24), date(2025, 7, 25))
-            
+            auth_handler = AuthHandler('test_user', 'test_pass')
+            auth_handler.auth_token = "test_token"
+            auth_handler.user_id = "12345"
+            session_manager = SessionManager(auth_handler)
+
+            result = session_manager.get_available_sessions(date(2025, 7, 24), date(2025, 7, 25))
+
             assert result is not None
             assert result["success"] is True
-    
+
     @patch('requests.Session.post')
     def test_get_available_sessions_401_error(self, mock_post):
         """Test get_available_sessions with 401 error"""
         mock_response = Mock()
         mock_response.status_code = 401
-        
+
         mock_post.return_value = mock_response
-        
+
         with patch.dict(os.environ, {
             'CROSSFIT_USERNAME': 'test_user',
             'CROSSFIT_PASSWORD': 'test_pass'
         }):
-            booker = CrossFitBooker()
-            booker.auth_token = "test_token"
-            booker.user_id = "12345"
-            
-            result = booker.get_available_sessions(date(2025, 7, 24), date(2025, 7, 25))
-            
-            assert result is None
+            auth_handler = AuthHandler('test_user', 'test_pass')
+            session_manager = SessionManager(auth_handler)
+            auth_handler.auth_token = "test_token"
+            auth_handler.user_id = "12345"
 
+            result = session_manager.get_available_sessions(date(2025, 7, 24), date(2025, 7, 25))
+
+            assert result is None
 
 class TestCrossFitBookerBookSession:
     """Test cases for book_session method"""
-    
+
     def test_book_session_no_auth(self):
         """Test book_session without authentication"""
         with patch.dict(os.environ, {
             'CROSSFIT_USERNAME': 'test_user',
             'CROSSFIT_PASSWORD': 'test_pass'
         }):
-            booker = CrossFitBooker()
-            result = booker.book_session("session_123")
+            auth_handler = AuthHandler('test_user', 'test_pass')
+            session_manager = SessionManager(auth_handler)
+            result = session_manager.book_session("session_123")
             assert result is False
-    
+
     @patch('requests.Session.post')
     def test_book_session_success(self, mock_post):
         """Test successful book_session"""
         mock_response = Mock()
         mock_response.status_code = 200
         mock_response.json.return_value = {"success": True}
-        
+
         mock_post.return_value = mock_response
-        
+
         with patch.dict(os.environ, {
             'CROSSFIT_USERNAME': 'test_user',
             'CROSSFIT_PASSWORD': 'test_pass'
         }):
-            booker = CrossFitBooker()
-            booker.auth_token = "test_token"
-            booker.user_id = "12345"
-            
-            result = booker.book_session("session_123")
-            
+            auth_handler = AuthHandler('test_user', 'test_pass')
+            auth_handler.auth_token = "test_token"
+            auth_handler.user_id = "12345"
+            session_manager = SessionManager(auth_handler)
+
+            result = session_manager.book_session("session_123")
+
             assert result is True
-    
+
     @patch('requests.Session.post')
     def test_book_session_api_failure(self, mock_post):
         """Test book_session with API failure"""
         mock_response = Mock()
         mock_response.status_code = 200
         mock_response.json.return_value = {"success": False, "error": "Session full"}
-        
+
         mock_post.return_value = mock_response
-        
+
         with patch.dict(os.environ, {
             'CROSSFIT_USERNAME': 'test_user',
             'CROSSFIT_PASSWORD': 'test_pass'
         }):
-            booker = CrossFitBooker()
-            booker.auth_token = "test_token"
-            booker.user_id = "12345"
-            
-            result = booker.book_session("session_123")
-            
-            assert result is False
+            auth_handler = AuthHandler('test_user', 'test_pass')
+            auth_handler.auth_token = "test_token"
+            auth_handler.user_id = "12345"
+            session_manager = SessionManager(auth_handler)
 
+            result = session_manager.book_session("session_123")
+
+            assert result is False
 
 class TestCrossFitBookerIsSessionBookable:
     """Test cases for is_session_bookable method"""
-    
+
     def test_is_session_bookable_can_join_true(self):
         """Test session bookable with can_join=True"""
         with patch.dict(os.environ, {
             'CROSSFIT_USERNAME': 'test_user',
             'CROSSFIT_PASSWORD': 'test_pass'
         }):
-            booker = CrossFitBooker()
+            auth_handler = AuthHandler('test_user', 'test_pass')
+            session_manager = SessionManager(auth_handler)
             session = {"user_info": {"can_join": True}}
             current_time = datetime.now(pytz.timezone("Europe/Paris"))
-            
-            result = booker.is_session_bookable(session, current_time)
+
+            result = session_manager.is_session_bookable(session, current_time)
             assert result is True
-    
+
     def test_is_session_bookable_booking_window_past(self):
         """Test session bookable with booking window in past"""
         with patch.dict(os.environ, {
             'CROSSFIT_USERNAME': 'test_user',
             'CROSSFIT_PASSWORD': 'test_pass'
         }):
-            booker = CrossFitBooker()
+            auth_handler = AuthHandler('test_user', 'test_pass')
+            session_manager = SessionManager(auth_handler)
             session = {
                 "user_info": {
                     "can_join": False,
@@ -167,17 +176,18 @@ class TestCrossFitBookerIsSessionBookable:
                 }
             }
             current_time = datetime.now(pytz.timezone("Europe/Paris"))
-            
-            result = booker.is_session_bookable(session, current_time)
+
+            result = session_manager.is_session_bookable(session, current_time)
             assert result is True
-    
+
     def test_is_session_bookable_booking_window_future(self):
         """Test session not bookable with booking window in future"""
         with patch.dict(os.environ, {
             'CROSSFIT_USERNAME': 'test_user',
             'CROSSFIT_PASSWORD': 'test_pass'
         }):
-            booker = CrossFitBooker()
+            auth_handler = AuthHandler('test_user', 'test_pass')
+            session_manager = SessionManager(auth_handler)
             session = {
                 "user_info": {
                     "can_join": False,
@@ -186,148 +196,31 @@ class TestCrossFitBookerIsSessionBookable:
                 }
             }
             current_time = datetime.now(pytz.timezone("Europe/Paris"))
-            
-            result = booker.is_session_bookable(session, current_time)
+
+            result = session_manager.is_session_bookable(session, current_time)
             assert result is False
 
 
-class TestCrossFitBookerRunBookingCycle:
-    """Test cases for run_booking_cycle method"""
-
-    @patch('crossfit_booker.CrossFitBooker.get_available_sessions')
-    @patch('crossfit_booker.CrossFitBooker.is_session_bookable')
-    @patch('crossfit_booker.CrossFitBooker.matches_preferred_session')
-    @patch('crossfit_booker.CrossFitBooker.book_session')
-    async def test_run_booking_cycle_no_sessions(self, mock_book_session, mock_matches_preferred, mock_is_bookable, mock_get_sessions):
-        """Test run_booking_cycle with no available sessions"""
-        mock_get_sessions.return_value = {"success": False}
-        booker = CrossFitBooker()
-        await booker.run_booking_cycle(datetime.now(pytz.timezone("Europe/Paris")))
-        mock_get_sessions.assert_called_once()
-        mock_book_session.assert_not_called()
-
-    @patch('crossfit_booker.CrossFitBooker.get_available_sessions')
-    @patch('crossfit_booker.CrossFitBooker.is_session_bookable')
-    @patch('crossfit_booker.CrossFitBooker.matches_preferred_session')
-    @patch('crossfit_booker.CrossFitBooker.book_session')
-    async def test_run_booking_cycle_with_sessions(self, mock_book_session, mock_matches_preferred, mock_is_bookable, mock_get_sessions):
-        """Test run_booking_cycle with available sessions"""
-        # Use current date for the session to ensure it falls within 0-2 day window
-        current_time = datetime.now(pytz.timezone("Europe/Paris"))
-        session_date = current_time.date()
-        
-        mock_get_sessions.return_value = {
-            "success": True,
-            "data": {
-                "activities_calendar": [
-                    {
-                        "id_activity_calendar": "1",
-                        "name_activity": "CONDITIONING",
-                        "start_timestamp": session_date.strftime("%Y-%m-%d") + " 18:30:00",
-                        "user_info": {"can_join": True}
-                    }
-                ]
-            }
-        }
-        mock_is_bookable.return_value = True
-        mock_matches_preferred.return_value = True
-        mock_book_session.return_value = True
-
-        booker = CrossFitBooker()
-        await booker.run_booking_cycle(current_time)
-
-        mock_get_sessions.assert_called_once()
-        mock_is_bookable.assert_called_once()
-        mock_matches_preferred.assert_called_once()
-        mock_book_session.assert_called_once()
-        assert mock_book_session.call_count == 1
-
-class TestCrossFitBookerRun:
-    """Test cases for run method"""
-
-    @patch('crossfit_booker.CrossFitBooker.login')
-    @patch('crossfit_booker.CrossFitBooker.run_booking_cycle')
-    async def test_run_auth_failure(self, mock_run_booking_cycle, mock_login):
-        """Test run with authentication failure"""
-        mock_login.return_value = False
-        booker = CrossFitBooker()
-        with patch.object(booker, 'run', new=booker.run) as mock_run:
-            await booker.run()
-            mock_login.assert_called_once()
-            mock_run_booking_cycle.assert_not_called()
-
-    @patch('crossfit_booker.CrossFitBooker.login')
-    @patch('crossfit_booker.CrossFitBooker.run_booking_cycle')
-    @patch('crossfit_booker.CrossFitBooker.quit')
-    @patch('time.sleep')
-    @patch('datetime.datetime')
-    async def test_run_booking_outside_window(self, mock_datetime, mock_sleep, mock_quit, mock_run_booking_cycle, mock_login):
-        """Test run with booking outside window"""
-        mock_login.return_value = True
-        mock_quit.return_value = None  # Prevent actual exit
-        
-        # Create a time outside the booking window (19:00)
-        tz = pytz.timezone("Europe/Paris")
-        mock_now = datetime(2025, 7, 25, 19, 0, tzinfo=tz)
-        mock_datetime.now.return_value = mock_now
-        
-        # Make sleep return immediately to allow one iteration, then break
-        call_count = 0
-        def sleep_side_effect(seconds):
-            nonlocal call_count
-            call_count += 1
-            if call_count >= 1:
-                # Break the loop after first sleep
-                raise KeyboardInterrupt("Test complete")
-            return None
-        
-        mock_sleep.side_effect = sleep_side_effect
-        
-        booker = CrossFitBooker()
-        
-        try:
-            await booker.run()
-        except KeyboardInterrupt:
-            pass  # Expected to break the loop
-        
-        # Verify login was called
-        mock_login.assert_called_once()
-        
-        # Verify run_booking_cycle was NOT called since we're outside the booking window
-        mock_run_booking_cycle.assert_not_called()
-        
-        # Verify quit was called (due to KeyboardInterrupt)
-        mock_quit.assert_called_once()
-
-class TestCrossFitBookerQuit:
-    """Test cases for quit method"""
-
-    def test_quit(self):
-        """Test quit method"""
-        booker = CrossFitBooker()
-        with patch('sys.exit') as mock_exit:
-            with pytest.raises(SystemExit) as excinfo:
-                booker.quit()
-            assert excinfo.value.code == 0
 class TestCrossFitBookerMatchesPreferredSession:
     """Test cases for matches_preferred_session method"""
-    
+
     def test_matches_preferred_session_exact_match(self):
         """Test exact match with preferred session"""
         with patch.dict(os.environ, {
             'CROSSFIT_USERNAME': 'test_user',
             'CROSSFIT_PASSWORD': 'test_pass'
         }):
-            booker = CrossFitBooker()
+            auth_handler = AuthHandler('test_user', 'test_pass')
+            session_manager = SessionManager(auth_handler)
             session = {
                 "start_timestamp": "2025-07-30 18:30:00",
                 "name_activity": "CONDITIONING"
             }
             current_time = datetime(2025, 7, 30, 12, 0, 0, tzinfo=pytz.timezone("Europe/Paris"))
-            
+
             # Mock PREFERRED_SESSIONS
-            with patch('crossfit_booker.PREFERRED_SESSIONS', [(2, "18:30", "CONDITIONING")]):
-                result = booker.matches_preferred_session(session, current_time)
+            with patch('src.session_manager.PREFERRED_SESSIONS', [(2, "18:30", "CONDITIONING")]):
+                result = session_manager.matches_preferred_session(session, current_time)
                 assert result is True
 
     def test_matches_preferred_session_fuzzy_match(self):
@@ -336,7 +229,8 @@ class TestCrossFitBookerMatchesPreferredSession:
             'CROSSFIT_USERNAME': 'test_user',
             'CROSSFIT_PASSWORD': 'test_pass'
         }):
-            booker = CrossFitBooker()
+            auth_handler = AuthHandler('test_user', 'test_pass')
+            session_manager = SessionManager(auth_handler)
             session = {
                 "start_timestamp": "2025-07-30 18:30:00",
                 "name_activity": "CONDITIONING WORKOUT"
@@ -344,8 +238,8 @@ class TestCrossFitBookerMatchesPreferredSession:
             current_time = datetime(2025, 7, 30, 12, 0, 0, tzinfo=pytz.timezone("Europe/Paris"))
 
             # Mock PREFERRED_SESSIONS
-            with patch('crossfit_booker.PREFERRED_SESSIONS', [(2, "18:30", "CONDITIONING")]):
-                result = booker.matches_preferred_session(session, current_time)
+            with patch('src.session_manager.PREFERRED_SESSIONS', [(2, "18:30", "CONDITIONING")]):
+                result = session_manager.matches_preferred_session(session, current_time)
                 assert result is True
 
     def test_matches_preferred_session_no_match(self):
@@ -354,7 +248,8 @@ class TestCrossFitBookerMatchesPreferredSession:
             'CROSSFIT_USERNAME': 'test_user',
             'CROSSFIT_PASSWORD': 'test_pass'
         }):
-            booker = CrossFitBooker()
+            auth_handler = AuthHandler('test_user', 'test_pass')
+            session_manager = SessionManager(auth_handler)
             session = {
                 "start_timestamp": "2025-07-30 18:30:00",
                 "name_activity": "YOGA"
@@ -362,6 +257,6 @@ class TestCrossFitBookerMatchesPreferredSession:
             current_time = datetime(2025, 7, 30, 12, 0, 0, tzinfo=pytz.timezone("Europe/Paris"))
 
             # Mock PREFERRED_SESSIONS
-            with patch('crossfit_booker.PREFERRED_SESSIONS', [(2, "18:30", "CONDITIONING")]):
-                result = booker.matches_preferred_session(session, current_time)
+            with patch('src.session_manager.PREFERRED_SESSIONS', [(2, "18:30", "CONDITIONING")]):
+                result = session_manager.matches_preferred_session(session, current_time)
                 assert result is False

test/test_session_config.py

@@ -7,13 +7,12 @@ import pytest
 import os
 import json
 from unittest.mock import patch, mock_open
-import logging
 
 # Add the parent directory to the path
 import sys
 sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 
-from session_config import SessionConfig
+from src.session_config import SessionConfig
 
 class TestSessionConfig:
 
@@ -38,18 +37,17 @@ class TestSessionConfig:
         """Test behavior when the config file is not found"""
         # Mock the open function to raise FileNotFoundError
         with patch('builtins.open', side_effect=FileNotFoundError):
-            with patch('logging.warning') as mock_warning:
-                sessions = SessionConfig.load_preferred_sessions()
+            with patch('logging.error') as mock_error:
+                with pytest.raises(SystemExit) as excinfo:
+                    SessionConfig.load_preferred_sessions()
 
-                # Verify warning was logged
-                mock_warning.assert_called_once()
-                assert "not found" in mock_warning.call_args[0][0]
+                # Verify error was logged
+                assert mock_error.call_count == 2
+                assert "not found" in mock_error.call_args_list[0][0][0]
+                assert "example" in mock_error.call_args_list[1][0][0]
 
-                # Verify default sessions are returned
-                assert len(sessions) == 3
-                assert sessions[0] == (2, "18:30", "CONDITIONING")
-                assert sessions[1] == (4, "17:00", "WEIGHTLIFTING")
-                assert sessions[2] == (5, "12:30", "HYROX")
+                # Verify SystemExit was raised with exit code 1
+                assert excinfo.value.code == 1
 
     def test_load_preferred_sessions_invalid_json(self):
         """Test behavior when the config file contains invalid JSON"""
@@ -58,18 +56,16 @@ class TestSessionConfig:
 
         # Mock the open function to return invalid JSON
         with patch('builtins.open', mock_open(read_data=invalid_json)):
-            with patch('logging.warning') as mock_warning:
-                sessions = SessionConfig.load_preferred_sessions()
+            with patch('logging.error') as mock_error:
+                with pytest.raises(SystemExit) as excinfo:
+                    SessionConfig.load_preferred_sessions()
 
-                # Verify warning was logged
-                mock_warning.assert_called_once()
-                assert "decode" in mock_warning.call_args[0][0]
+                # Verify error was logged
+                mock_error.assert_called_once()
+                assert "decode" in mock_error.call_args[0][0]
 
-                # Verify default sessions are returned
-                assert len(sessions) == 3
-                assert sessions[0] == (2, "18:30", "CONDITIONING")
-                assert sessions[1] == (4, "17:00", "WEIGHTLIFTING")
-                assert sessions[2] == (5, "12:30", "HYROX")
+                # Verify SystemExit was raised with exit code 1
+                assert excinfo.value.code == 1
 
     def test_load_preferred_sessions_empty_file(self):
         """Test behavior when the config file is empty"""
@@ -80,11 +76,8 @@ class TestSessionConfig:
         with patch('builtins.open', mock_open(read_data=empty_json)):
             sessions = SessionConfig.load_preferred_sessions()
 
-            # Verify default sessions are returned
-            assert len(sessions) == 3
-            assert sessions[0] == (2, "18:30", "CONDITIONING")
-            assert sessions[1] == (4, "17:00", "WEIGHTLIFTING")
-            assert sessions[2] == (5, "12:30", "HYROX")
+            # Verify empty list is returned
+            assert sessions == []
 
     def test_load_preferred_sessions_missing_fields(self):
         """Test behavior when some fields are missing in the JSON data"""
@@ -112,18 +105,16 @@ class TestSessionConfig:
 
         # Mock the open function to return partial JSON
         with patch('builtins.open', mock_open(read_data=partial_json)):
-            with patch('logging.warning') as mock_warning:
-                sessions = SessionConfig.load_preferred_sessions()
+            with patch('logging.error') as mock_error:
+                with pytest.raises(SystemExit) as excinfo:
+                    SessionConfig.load_preferred_sessions()
 
-                # Verify warning was logged
-                mock_warning.assert_called_once()
-                assert "decode" in mock_warning.call_args[0][0]
+                # Verify error was logged
+                mock_error.assert_called_once()
+                assert "decode" in mock_error.call_args[0][0]
 
-                # Verify default sessions are returned
-                assert len(sessions) == 3
-                assert sessions[0] == (2, "18:30", "CONDITIONING")
-                assert sessions[1] == (4, "17:00", "WEIGHTLIFTING")
-                assert sessions[2] == (5, "12:30", "HYROX")
+                # Verify SystemExit was raised with exit code 1
+                assert excinfo.value.code == 1
 
     def test_load_preferred_sessions_incorrect_field_types(self):
         """Test behavior when the config file contains JSON with incorrect field types"""

test/test_session_notifier.py

@@ -7,13 +7,12 @@ import pytest
 import os
 import asyncio
 from unittest.mock import patch, MagicMock
-import logging
 
 # Add the parent directory to the path
 import sys
 sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 
-from session_notifier import SessionNotifier
+from src.session_notifier import SessionNotifier
 
 @pytest.fixture
 def email_credentials():

tools/execute_book_session.py

@@ -0,0 +1,80 @@
+#!/usr/bin/env python3
+"""
+Script to demonstrate how to execute the book_session method from crossfit_booker.py
+"""
+
+import sys
+import os
+import logging
+from src.auth import AuthHandler
+from src.booker import Booker
+from src.session_notifier import SessionNotifier
+
+# Load environment variables
+from dotenv import load_dotenv
+load_dotenv()
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
+def main():
+    # Check if a session ID was provided as an argument
+    if len(sys.argv) < 2:
+        print("Usage: python execute_book_session.py <session_id>")
+        sys.exit(1)
+
+    session_id = sys.argv[1]
+
+    # Initialize components
+    auth_handler = AuthHandler(
+        os.environ.get("CROSSFIT_USERNAME"),
+        os.environ.get("CROSSFIT_PASSWORD")
+    )
+
+    # Initialize notification system (minimal for single session booking)
+    email_credentials = {
+        "from": os.environ.get("EMAIL_FROM"),
+        "to": os.environ.get("EMAIL_TO"),
+        "password": os.environ.get("EMAIL_PASSWORD")
+    }
+
+    telegram_credentials = {
+        "token": os.environ.get("TELEGRAM_TOKEN"),
+        "chat_id": os.environ.get("TELEGRAM_CHAT_ID")
+    }
+
+    enable_email = os.environ.get("ENABLE_EMAIL_NOTIFICATIONS", "true").lower() in ("true", "1", "yes")
+    enable_telegram = os.environ.get("ENABLE_TELEGRAM_NOTIFICATIONS", "true").lower() in ("true", "1", "yes")
+
+    notifier = SessionNotifier(
+        email_credentials,
+        telegram_credentials,
+        enable_email=enable_email,
+        enable_telegram=enable_telegram
+    )
+
+    # Create an instance of Booker
+    booker = Booker(auth_handler, notifier)
+
+    # Login to authenticate
+    print("Attempting to authenticate...")
+    if not auth_handler.login():
+        print("Failed to authenticate. Please check your credentials and try again.")
+        sys.exit(1)
+    print("Authentication successful!")
+
+    # Book the session
+    print(f"Attempting to book session with ID: {session_id}")
+    success = booker.book_session(session_id)
+
+    if success:
+        print(f"Successfully booked session {session_id}")
+    else:
+        print(f"Failed to book session {session_id}")
+
+if __name__ == "__main__":
+    try:
+        main()
+    except Exception as e:
+        print(f"An error occurred: {e}")
+        sys.exit(1)

tools/execute_book_session.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+# Test script to demonstrate how to use the execute_book_session.py script
+
+# Sample session ID (this should be a valid session ID from the crossfit booking system)
+SESSION_ID="19291768"
+
+# Run the script with the sample session ID
+echo "Attempting to book session with ID: $SESSION_ID"
+python execute_book_session.py $SESSION_ID

tools/test_telegram_notifier.py

@@ -10,7 +10,7 @@ from dotenv import load_dotenv
 import sys
 
 sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-from session_notifier import SessionNotifier
+from src.session_notifier import SessionNotifier
 
 # Load environment variables from .env file
 load_dotenv()