pysportbot 0.0.16__py3-none-any.whl → 0.0.18__py3-none-any.whl

pysportbot/__init__.py

@@ -25,10 +25,32 @@ class SportBot:
         self._centres = Centres(print_centres)
         self._session: Session = Session()
         self._auth: Authenticator | None = None
-        self._activities: Activities = Activities(self._session)
-        self._bookings: Bookings = Bookings(self._session)
+        self._activities: Activities | None = None
+        self._bookings: Bookings | None = None
         self._df_activities: DataFrame | None = None
-        self._is_logged_in: bool = False  # State variable for login status
+        self._is_logged_in: bool = False
+
+    @property
+    def activities_manager(self) -> Activities:
+        """Get the activities manager, ensuring user is logged in."""
+        if not self._is_logged_in or self._auth is None:
+            raise PermissionError(ErrorMessages.not_logged_in())
+
+        # Lazy initialization - create only when first needed
+        if self._activities is None:
+            self._activities = Activities(self._auth)
+        return self._activities
+
+    @property
+    def bookings_manager(self) -> Bookings:
+        """Get the bookings manager, ensuring user is logged in."""
+        if not self._is_logged_in or self._auth is None:
+            raise PermissionError(ErrorMessages.not_logged_in())
+
+        # Lazy initialization - create only when first needed
+        if self._bookings is None:
+            self._bookings = Bookings(self._auth)
+        return self._bookings
 
     def set_log_level(self, log_level: str) -> None:
         set_log_level(log_level)
@@ -44,12 +66,19 @@ class SportBot:
 
         self._logger.info("Attempting to log in...")
         try:
+            # Login to get valid credentials
             self._auth.login(email, password)
-            self._df_activities = self._activities.fetch()
             self._is_logged_in = True
             self._logger.info("Login successful!")
+
+            # Fetch activities on first successful login
+            self._df_activities = self.activities_manager.fetch()
         except Exception:
             self._is_logged_in = False
+            # Clean up on failure
+            self._activities = None
+            self._bookings = None
+            self._auth = None
             self._logger.exception(ErrorMessages.login_failed())
             raise
 
@@ -58,37 +87,21 @@ class SportBot:
         return self._is_logged_in
 
     def activities(self, limit: int | None = None) -> DataFrame:
-        if not self._is_logged_in:
-            self._logger.error(ErrorMessages.not_logged_in())
-            raise PermissionError(ErrorMessages.not_logged_in())
-
         if self._df_activities is None:
-            self._logger.error(ErrorMessages.no_activities_loaded())
             raise ValueError(ErrorMessages.no_activities_loaded())
 
         df = self._df_activities[["name_activity", "id_activity"]]
         return df.head(limit) if limit else df
 
     def daily_slots(self, activity: str, day: str, limit: int | None = None) -> DataFrame:
-        if not self._is_logged_in:
-            self._logger.error(ErrorMessages.not_logged_in())
-            raise PermissionError(ErrorMessages.not_logged_in())
-
         if self._df_activities is None:
-            self._logger.error(ErrorMessages.no_activities_loaded())
             raise ValueError(ErrorMessages.no_activities_loaded())
 
-        df = self._activities.daily_slots(self._df_activities, activity, day)
+        df = self.activities_manager.daily_slots(self._df_activities, activity, day)
         return df.head(limit) if limit else df
 
     def book(self, activity: str, start_time: str) -> None:
-
-        if not self._is_logged_in:
-            self._logger.error(ErrorMessages.not_logged_in())
-            raise PermissionError(ErrorMessages.not_logged_in())
-
         if self._df_activities is None:
-            self._logger.error(ErrorMessages.no_activities_loaded())
             raise ValueError(ErrorMessages.no_activities_loaded())
 
         # Fetch the daily slots for the activity
@@ -108,7 +121,7 @@ class SportBot:
         # The unique slot ID
         slot_id = target_slot["id_activity_calendar"]
         # The total member capacity of the slot
-        slot_capacity = target_slot["capacity"]
+        slot_capacity = target_slot["n_capacity"]
         # The number of members already inscribed in the slot
         slot_n_inscribed = target_slot["n_inscribed"]
         # Log slot capacity
@@ -123,20 +136,15 @@ class SportBot:
 
         # Attempt to book the slot
         try:
-            self._bookings.book(slot_id)
+            self.bookings_manager.book(slot_id)
             self._logger.info(f"Successfully booked class '{activity}' on {start_time}")
         except ValueError:
             self._logger.error(f"Failed to book class '{activity}' on {start_time}")
 
     def cancel(self, activity: str, start_time: str) -> None:
-
         self._logger.debug(f"Attempting to cancel class '{activity}' on {start_time}")
-        if not self._is_logged_in:
-            self._logger.error(ErrorMessages.not_logged_in())
-            raise PermissionError(ErrorMessages.not_logged_in())
 
         if self._df_activities is None:
-            self._logger.error(ErrorMessages.no_activities_loaded())
             raise ValueError(ErrorMessages.no_activities_loaded())
 
         slots = self.daily_slots(activity, start_time.split(" ")[0])
@@ -148,7 +156,7 @@ class SportBot:
 
         slot_id = matching_slot.iloc[0]["id_activity_calendar"]
         try:
-            self._bookings.cancel(slot_id)
+            self.bookings_manager.cancel(slot_id)
             self._logger.info(f"Successfully cancelled class '{activity}' on {start_time}")
         except ValueError:
             self._logger.error(f"Failed to cancel class '{activity}' on {start_time}")

pysportbot/activities.py

@@ -1,13 +1,14 @@
 import json
+from datetime import datetime, timedelta
 
 import pandas as pd
 from pandas import DataFrame
 
+from .authenticator import Authenticator
 from .endpoints import Endpoints
-from .session import Session
 from .utils.errors import ErrorMessages
 from .utils.logger import get_logger
-from .utils.time import get_unix_day_bounds
+from .utils.time import get_day_bounds
 
 logger = get_logger(__name__)
 
@@ -15,43 +16,89 @@ logger = get_logger(__name__)
 class Activities:
     """Handles activity fetching and slot management."""
 
-    def __init__(self, session: Session) -> None:
+    def __init__(self, authenticator: Authenticator) -> None:
         """Initialize the Activities class."""
-        self.session = session.session
-        self.headers = session.headers
-
-    def fetch(self) -> DataFrame:
+        # Session
+        self.session = authenticator.session
+        # Nubapp credentials
+        self.creds = authenticator.creds
+        # Headers for requests
+        self.headers = authenticator.headers
+
+    def fetch(self, days_ahead: int = 7) -> DataFrame:
         """
-        Fetch all available activities.
+        Fetch all available unique activities within a specified time range using SLOTS endpoint.
+
+        Args:
+            days_ahead (int): Number of days from now to fetch activities for. Defaults to 7.
 
         Returns:
-            DataFrame: A DataFrame containing activity details.
+            DataFrame: A DataFrame containing unique activity details with columns:
+                    ['id_activity', 'name_activity', 'id_category_activity']
 
         Raises:
-            RuntimeError: If the request fails.
+            RuntimeError: If the request fails or JSON parsing fails.
         """
-        logger.info("Fetching activities...")
-        response = self.session.post(Endpoints.ACTIVITIES, headers=self.headers)
+        logger.info(f"Fetching activities for the next {days_ahead} days. This might take a while...")
+
+        # Calculate date range
+        start_date = datetime.now().strftime("%Y-%m-%d")
+        end_date = (datetime.now() + timedelta(days=days_ahead)).strftime("%Y-%m-%d")
+
+        # Get day bounds for the date range
+        start_timestamp = get_day_bounds(start_date)[0]
+        end_timestamp = get_day_bounds(end_date)[1]
+
+        # Prepare payload for SLOTS endpoint
+        payload = {
+            "id_application": self.creds.get("id_application"),
+            "id_user": self.creds.get("id_user"),
+            "start_timestamp": start_timestamp,
+            "end_timestamp": end_timestamp,
+        }
+        # Make request to SLOTS endpoint
+        response = self.session.post(Endpoints.SLOTS, headers=self.headers, data=payload)
 
         if response.status_code != 200:
-            error_msg = ErrorMessages.failed_fetch("activities")
-            logger.error(error_msg)
+            error_msg = ErrorMessages.failed_fetch("activities from slots")
+            logger.error(f"{error_msg} Status Code: {response.status_code}")
             raise RuntimeError(error_msg)
 
         try:
-            activities = response.json().get("activities", {})
+            data = json.loads(response.content.decode("utf-8"))
+            activities = data["data"]["activities_calendar"]
+
+            if not activities:
+                logger.warning("No activities found in the response.")
+                return pd.DataFrame(columns=["id_activity", "name_activity", "id_category_activity"])
+
+            # Create DataFrame from activities
+            df_activities = pd.DataFrame(activities)
+
+            # Drop duplicates based on 'id_activity' and keep first occurrence
+            df_activities = df_activities.drop_duplicates(subset=["id_activity"])
+
+            # Select only required columns and reset index
+            df_activities = df_activities[["id_activity", "name_activity", "id_category_activity"]].reset_index(
+                drop=True
+            )
+
         except json.JSONDecodeError as err:
-            error_msg = "Invalid JSON response while fetching activities."
+            error_msg = "Invalid JSON response while fetching activities from slots."
+            logger.error(error_msg)
+            logger.error(f"Raw response: {response.content.decode('utf-8')}")
+            raise RuntimeError(error_msg) from err
+        except KeyError as err:
+            error_msg = f"Missing expected key in response: {err}"
+            logger.error(error_msg)
+            logger.error(f"Raw response: {response.content.decode('utf-8')}")
+            raise RuntimeError(error_msg) from err
+        except Exception as err:
+            error_msg = f"Unexpected error while parsing activities: {err}"
             logger.error(error_msg)
             raise RuntimeError(error_msg) from err
 
-        if not activities:
-            logger.warning("No activities found in the response.")
-
-        df_activities = pd.DataFrame.from_dict(activities, orient="index")
-        df_activities.index = df_activities.index.astype(int)  # Ensure index is integer for consistency
-
-        logger.info("Activities fetched successfully.")
+        logger.info(f"Successfully fetched {len(df_activities)} unique activities.")
         return df_activities
 
     def daily_slots(self, df_activities: DataFrame, activity_name: str, day: str) -> DataFrame:
@@ -81,21 +128,22 @@ class Activities:
             logger.error(error_msg)
             raise ValueError(error_msg)
 
-        # Extract activity ID and category ID
-        # Ensures activity_id is an integer
-        activity_id = activity_match.index[0]
-        id_category_activity = activity_match.at[activity_id, "activityCategoryId"]
+        activity = activity_match.iloc[0]
+        id_activity = activity["id_activity"]
+        id_category_activity = activity["id_category_activity"]
 
         # Get Unix timestamp bounds for the day
-        unix_day_bounds = get_unix_day_bounds(day)
+        day_bounds = get_day_bounds(day)
 
         # Fetch slots
-        params = {
+        payload = {
+            "id_application": self.creds["id_application"],
+            "id_user": self.creds["id_user"],
+            "start_timestamp": day_bounds[0],
+            "end_timestamp": day_bounds[1],
             "id_category_activity": id_category_activity,
-            "start": unix_day_bounds[0],
-            "end": unix_day_bounds[1],
         }
-        response = self.session.get(Endpoints.SLOTS, headers=self.headers, params=params)
+        response = self.session.post(Endpoints.SLOTS, headers=self.headers, data=payload)
 
         if response.status_code != 200:
             error_msg = ErrorMessages.failed_fetch("slots")
@@ -103,11 +151,16 @@ class Activities:
             raise RuntimeError(error_msg)
 
         try:
-            slots = response.json()
+            data = json.loads(response.content.decode("utf-8"))
+            slots = data["data"]["activities_calendar"]
         except json.JSONDecodeError as err:
             error_msg = "Invalid JSON response while fetching slots."
             logger.error(error_msg)
             raise RuntimeError(error_msg) from err
+        except KeyError as err:
+            error_msg = f"Missing expected key in response: {err}"
+            logger.error(error_msg)
+            raise RuntimeError(error_msg) from err
 
         if not slots:
             warning_msg = ErrorMessages.no_slots(activity_name, day)
@@ -125,11 +178,10 @@ class Activities:
             "start_timestamp",
             "end_timestamp",
             "n_inscribed",
-            "capacity",
+            "n_capacity",
             "n_waiting_list",
             "cancelled",
-            "can_join",
-            "trainer",
+            "trainer_name",
         ]
         df_slots = pd.DataFrame(slots)
 
@@ -137,7 +189,7 @@ class Activities:
         df_slots = df_slots.loc[:, df_slots.columns.intersection(columns)]
 
         # Only select rows of the specified activity
-        df_slots = df_slots[df_slots["id_activity"] == activity_id]
+        df_slots = df_slots[df_slots.id_activity == int(id_activity)]
         if df_slots.empty:
             warning_msg = ErrorMessages.no_matching_slots(activity_name, day)
             logger.warning(warning_msg)

pysportbot/authenticator.py

@@ -1,6 +1,5 @@
-import ast
 import json
-from urllib.parse import parse_qs
+from urllib.parse import parse_qs, urlparse
 
 from bs4 import BeautifulSoup
 
@@ -21,15 +20,37 @@ class Authenticator:
 
         Args:
             session (Session): An instance of the Session class.
+            centre (str): The centre selected by the user.
         """
         self.session = session.session
         self.headers = session.headers
-        # Has the user successfully authenticated?
-        self.authenticated = False
-        # User ID for the authenticated user
-        self.user_id = None
-        # Centre selected by the user
+        self.creds: dict[str, str] = {}
         self.centre = centre
+        self.timeout = (5, 10)
+
+        # Authentication state
+        self.authenticated = False
+        self.user_id: str | None = None
+
+    def is_session_valid(self) -> bool:
+        """
+        Check if the current session is still valid.
+
+        Returns:
+            bool: True if session is valid, False otherwise.
+        """
+        try:
+            response = self.session.post(Endpoints.USER, headers=self.headers, timeout=self.timeout)
+            if response.status_code == 200:
+                response_dict = json.loads(response.content.decode("utf-8"))
+                return bool(response_dict.get("user"))
+
+        except Exception as e:
+            logger.debug(f"Session validation failed with exception: {e}")
+            return False
+
+        logger.debug(f"Session validation failed with status code: {response.status_code}")
+        return False
 
     def login(self, email: str, password: str) -> None:
         """
@@ -40,24 +61,53 @@ class Authenticator:
             password (str): The user's password.
 
         Raises:
-            RuntimeError: If the login process fails at any stage.
+            ValueError: If login credentials are invalid or authentication fails.
+            RuntimeError: If the login process fails due to system errors.
         """
         logger.info("Starting login process...")
 
-        # Step 1: Fetch CSRF token
-        logger.debug(f"GET {Endpoints.USER_LOGIN} | Headers: {json.dumps(self.headers, indent=2)}")
-        response = self.session.get(Endpoints.USER_LOGIN, headers=self.headers)
+        try:
+            # Fetch the CSRF token and perform login
+            csrf_token = self._fetch_csrf_token()
+            # Resasport login with CSRF token
+            self._resasports_login(email, password, csrf_token)
+            # Retrieve Nubapp credentials
+            self._retrieve_nubapp_credentials()
+            bearer_token = self._login_to_nubapp()
+            # Authenticate with the bearer token
+            self._authenticate_with_bearer_token(bearer_token)
+            # Fetch user information to complete the login process
+            self._fetch_user_information()
+
+            logger.info("Login process completed successfully!")
+
+        except Exception as e:
+            self.authenticated = False
+            self.user_id = None
+            logger.error(f"Login process failed: {e}")
+            raise
+
+    def _fetch_csrf_token(self) -> str:
+        """Fetch CSRF token from the login page."""
+        logger.debug(f"Fetching CSRF token from {Endpoints.USER_LOGIN}")
+
+        response = self.session.get(Endpoints.USER_LOGIN, headers=self.headers, timeout=self.timeout)
         if response.status_code != 200:
-            logger.error(f"Failed to fetch login popup: {response.status_code}")
             raise RuntimeError(ErrorMessages.failed_fetch("login popup"))
-        logger.debug("Login popup fetched successfully.")
+
         soup = BeautifulSoup(response.text, "html.parser")
         csrf_tag = soup.find("input", {"name": "_csrf_token"})
         if csrf_tag is None:
             raise ValueError("CSRF token input not found on the page")
-        csrf_token = csrf_tag["value"]  # type: ignore[index]
 
-        # Step 2: Perform login
+        csrf_token = str(csrf_tag["value"])  # type: ignore[index]
+        logger.debug("CSRF token fetched successfully")
+        return csrf_token
+
+    def _resasports_login(self, email: str, password: str, csrf_token: str) -> None:
+        """Perform login to the main site."""
+        logger.debug("Performing site login")
+
         payload = {
             "_username": email,
             "_password": password,
@@ -65,58 +115,103 @@ class Authenticator:
             "_submit": "",
             "_force": "true",
         }
-        self.headers.update({"Content-Type": "application/x-www-form-urlencoded"})
-        logger.debug(
-            f"POST {Endpoints.LOGIN_CHECK} | Headers: {json.dumps(self.headers, indent=2)} | "
-            f"Payload: {json.dumps(payload, indent=2)}"
-        )
-        response = self.session.post(Endpoints.LOGIN_CHECK, data=payload, headers=self.headers)
+
+        headers = self.headers.copy()
+        headers.update({"Content-Type": "application/x-www-form-urlencoded"})
+
+        response = self.session.post(Endpoints.LOGIN_CHECK, data=payload, headers=headers, timeout=self.timeout)
+
         if response.status_code != 200:
-            logger.error(f"Login failed: {response.status_code}, {response.text}")
+            logger.error(f"Site login failed: {response.status_code}")
             raise ValueError(ErrorMessages.failed_login())
-        logger.info("Login successful!")
 
-        # Step 3: Retrieve credentials for Nubapp
+        logger.info("Site login successful!")
+
+    def _retrieve_nubapp_credentials(self) -> None:
+        """Retrieve Nubapp credentials from the centre endpoint."""
+        logger.debug("Retrieving Nubapp credentials")
+
         cred_endpoint = Endpoints.get_cred_endpoint(self.centre)
-        logger.debug(f"GET {cred_endpoint} | Headers: {json.dumps(self.headers, indent=2)}")
-        response = self.session.get(cred_endpoint, headers=self.headers)
+        response = self.session.get(cred_endpoint, headers=self.headers, timeout=self.timeout)
+
         if response.status_code != 200:
-            logger.error(f"Failed to retrieve Nubapp credentials: {response.status_code}")
             raise RuntimeError(ErrorMessages.failed_fetch("credentials"))
-        nubapp_creds = ast.literal_eval(response.content.decode("utf-8"))["payload"]
-        nubapp_creds = {k: v[0] for k, v in parse_qs(nubapp_creds).items()}
-        nubapp_creds["platform"] = "resasocial"
-        nubapp_creds["network"] = "resasports"
-        logger.debug(f"Nubapp credentials retrieved: {json.dumps(nubapp_creds, indent=2)}")
-
-        # Step 4: Log in to Nubapp
-        logger.debug(
-            f"GET {Endpoints.NUBAP_LOGIN} | Headers: {json.dumps(self.headers, indent=2)} | "
-            f"Params: {json.dumps(nubapp_creds, indent=2)}"
+
+        try:
+            response_data = json.loads(response.content.decode("utf-8"))
+            creds_payload = response_data.get("payload", "")
+            creds = {k: v[0] for k, v in parse_qs(creds_payload).items()}
+            creds.update({"platform": "resasocial", "network": "resasports"})
+
+            self.creds = creds
+            logger.debug("Nubapp credentials retrieved successfully")
+
+        except (ValueError, KeyError, SyntaxError) as e:
+            raise RuntimeError(f"Failed to parse credentials: {e}") from e
+
+    def _login_to_nubapp(self) -> str:
+        """Login to Nubapp and extract bearer token."""
+        logger.debug("Logging in to Nubapp")
+
+        response = self.session.get(
+            Endpoints.NUBAPP_LOGIN,
+            headers=self.headers,
+            params=self.creds,
+            timeout=self.timeout,
+            allow_redirects=False,
         )
-        response = self.session.get(Endpoints.NUBAP_LOGIN, headers=self.headers, params=nubapp_creds)
-        if response.status_code != 200:
-            logger.error(f"Login to Nubapp failed: {response.status_code}, {response.text}")
-            raise ValueError(ErrorMessages.failed_login_nubapp())
-        logger.info("Login to Nubapp successful!")
 
-        # Step 5: Get user information
-        response = self.session.post(Endpoints.USER, headers=self.headers, allow_redirects=True)
+        if response.status_code != 302:
+            logger.error(f"Nubapp login failed: {response.status_code}")
+            raise ValueError(ErrorMessages.failed_login())
+
+        # Extract bearer token from redirect URL
+        redirect_url = response.headers.get("Location", "")
+        if not redirect_url:
+            raise ValueError(ErrorMessages.failed_login())
 
-        if response.status_code == 200:
-            response_dict = json.loads(response.content.decode("utf-8"))
+        parsed_url = urlparse(redirect_url)
+        token = parse_qs(parsed_url.query).get("token", [None])[0]
+
+        if not token:
+            raise ValueError(ErrorMessages.failed_login())
+
+        logger.info("Nubapp login successful!")
+        return token
+
+    def _authenticate_with_bearer_token(self, token: str) -> None:
+        """Add bearer token to headers for authentication."""
+        logger.debug("Setting up bearer token authentication")
+        self.headers["Authorization"] = f"Bearer {token}"
+
+    def _fetch_user_information(self) -> None:
+        """Fetch and validate user information."""
+        logger.debug("Fetching user information")
 
-            if response_dict["user"]:
-                self.user_id = response_dict.get("user", {}).get("id_user")
-                if self.user_id:
-                    self.authenticated = True
-                    logger.info(f"Authentication successful. User ID: {self.user_id}")
-                else:
-                    self.authenticated = False
-                    raise ValueError()
-            else:
-                self.authenticated = False
-                raise ValueError(ErrorMessages.failed_login())
-        else:
-            logger.error(f"Failed to retrieve user information: {response.status_code}, {response.text}")
+        payload = {
+            "id_application": self.creds["id_application"],
+            "id_user": self.creds["id_user"],
+        }
+
+        response = self.session.post(Endpoints.USER, headers=self.headers, data=payload, timeout=self.timeout)
+
+        if response.status_code != 200:
             raise ValueError(ErrorMessages.failed_login())
+
+        try:
+            response_dict = json.loads(response.content.decode("utf-8"))
+            user_data = response_dict.get("data", {}).get("user")
+
+            if not user_data:
+                raise ValueError("No user data found in response")
+
+            user_id = user_data.get("id_user")
+            if not user_id:
+                raise ValueError("No user ID found in response")
+
+            self.user_id = str(user_id)
+            self.authenticated = True
+            logger.info(f"Authentication successful. User ID: {self.user_id}")
+
+        except (json.JSONDecodeError, KeyError) as e:
+            raise ValueError(f"Failed to parse user information: {e}") from e

pysportbot/bookings.py

@@ -1,7 +1,7 @@
 import json
 
+from .authenticator import Authenticator
 from .endpoints import Endpoints
-from .session import Session
 from .utils.errors import ErrorMessages
 from .utils.logger import get_logger
 
@@ -11,10 +11,14 @@ logger = get_logger(__name__)
 class Bookings:
     """Handles booking and cancellation of activity slots."""
 
-    def __init__(self, session: Session) -> None:
+    def __init__(self, authenticator: Authenticator) -> None:
         """Initialize the Bookings class."""
-        self.session = session.session
-        self.headers = session.headers
+        # Session
+        self.session = authenticator.session
+        # Nubapp credentials
+        self.creds = authenticator.creds
+        # Headers for requests
+        self.headers = authenticator.headers
 
     def book(self, slot_id: str) -> None:
         """
@@ -30,35 +34,30 @@ class Bookings:
         logger.debug(f"Attempting to book slot {slot_id}...")
 
         # Payload for booking
-        payload = {
-            "items[activities][0][id_activity_calendar]": slot_id,
-            "items[activities][0][unit_price]": "0",
-            "items[activities][0][n_guests]": "0",
-            "items[activities][0][id_resource]": "false",
-            "discount_code": "false",
-            "form": "",
-            "formIntoNotes": "",
-        }
+        payload = {"id_user": self.creds["id_user"], "id_activity_calendar": slot_id}
 
         # Send booking request
         response = self.session.post(Endpoints.BOOKING, data=payload, headers=self.headers)
         response_json = json.loads(response.content.decode("utf-8"))
-
-        # Handle response
-        if response_json["error"] == 0:
+        # Check success directly
+        if response_json["success"]:
             logger.debug(f"Successfully booked slot {slot_id}.")
-        elif response_json["error"] == 5:
-            logger.warning(f"Slot {slot_id} is already booked.")
-            raise ValueError(ErrorMessages.slot_already_booked())
-        elif response_json["error"] == 6:
-            logger.warning(f"Slot {slot_id} is not available.")
-            raise ValueError(ErrorMessages.slot_unavailable())
-        elif response_json["error"] == 28:
-            logger.warning(f"Slot {slot_id} is not bookable yet.")
-            raise ValueError(ErrorMessages.slot_not_bookable_yet())
         else:
-            logger.error(f"Booking failed with error code: {response_json['error']}")
-            raise RuntimeError(ErrorMessages.unknown_error("booking"))
+            # Handle error cases
+            error_code = response_json["error"]  # Now we know it exists when success=False
+
+            if error_code == 5:
+                logger.warning(f"Slot {slot_id} is already booked.")
+                raise ValueError(ErrorMessages.slot_already_booked())
+            elif error_code == 6:
+                logger.warning(f"Slot {slot_id} is not available.")
+                raise ValueError(ErrorMessages.slot_unavailable())
+            elif error_code == 28:
+                logger.warning(f"Slot {slot_id} is not bookable yet.")
+                raise ValueError(ErrorMessages.slot_not_bookable_yet())
+            else:
+                logger.error(f"Booking failed with error code: {error_code}")
+                raise RuntimeError(ErrorMessages.unknown_error("booking"))
 
     def cancel(self, slot_id: str) -> None:
         """
@@ -73,7 +72,7 @@ class Bookings:
         logger.debug(f"Attempting to cancel slot {slot_id}...")
 
         # Payload for cancellation
-        payload = {"id_activity_calendar": slot_id}
+        payload = {"id_user": self.creds["id_user"], "id_activity_calendar": slot_id}
 
         # Send cancellation request
         response = self.session.post(Endpoints.CANCELLATION, data=payload, headers=self.headers)

pysportbot/endpoints.py

@@ -3,38 +3,56 @@ from enum import Enum
 
 class Endpoints(str, Enum):
     """
-    Enum class for API endpoints used in the application.
-    Each member is a string, so you can use them directly.
+    API endpoints used throughout the application.
+
+    This enum provides type-safe access to all API endpoints with clear organization
+    and automatic string conversion for use in HTTP requests.
     """
 
-    # Base URLs
+    # === Base URLs ===
     BASE_SOCIAL = "https://social.resasports.com"
-    BASE_NUBAPP = "https://sport.nubapp.com/web"
+    BASE_NUBAPP = "https://sport.nubapp.com"
+
+    # === URL Components ===
+    NUBAPP_RESOURCES = "web/resources"
+    NUBAPP_API = "api/v4"
 
-    # Centre list
+    # === Centre Management ===
     CENTRE = f"{BASE_SOCIAL}/ajax/applications/bounds/"
 
-    # Authentication Endpoints
+    # === Authentication ===
     USER_LOGIN = f"{BASE_SOCIAL}/popup/login"
     LOGIN_CHECK = f"{BASE_SOCIAL}/popup/login_check"
-    NUBAP_LOGIN = f"{BASE_NUBAPP}/resources/login_from_social.php"
+    NUBAPP_LOGIN = f"{BASE_NUBAPP}/{NUBAPP_RESOURCES}/login_from_social.php"
+
+    # === User Management ===
+    USER = f"{BASE_NUBAPP}/{NUBAPP_API}/users/getUser.php"
 
-    # User, activities, and slots
-    USER = f"{BASE_NUBAPP}/ajax/users/getUser.php"
-    ACTIVITIES = f"{BASE_NUBAPP}/ajax/application/getActivities.php"
-    SLOTS = f"{BASE_NUBAPP}/ajax/activities/getActivitiesCalendar.php"
+    # === Activities & Scheduling ===
+    ACTIVITIES = f"{BASE_NUBAPP}/{NUBAPP_API}/activities/getActivities.php"
+    SLOTS = f"{BASE_NUBAPP}/{NUBAPP_API}/activities/getActivitiesCalendar.php"
 
-    # Booking and Cancellation
-    BOOKING = f"{BASE_NUBAPP}/ajax/bookings/bookBookings.php"
-    CANCELLATION = f"{BASE_NUBAPP}/ajax/activities/leaveActivityCalendar.php"
+    # === Booking Management ===
+    BOOKING = f"{BASE_NUBAPP}/{NUBAPP_API}/activities/bookActivityCalendar.php"
+    CANCELLATION = f"{BASE_NUBAPP}/{NUBAPP_API}/activities/leaveActivityCalendar.php"
 
     @classmethod
     def get_cred_endpoint(cls, centre_slug: str) -> str:
         """
-        Build the booking request URL for a given centre slug.
+        Generate the credentials endpoint for a specific centre.
+
+        Args:
+            centre_slug (str): The unique identifier for the sports centre
+
+        Returns:
+            str: Complete URL for fetching centre credentials
+
+        Example:
+            >>> Endpoints.get_cred_endpoint("kirolklub")
+            "https://social.resasports.com/ajax/application/kirolklub/book/request"
         """
         return f"{cls.BASE_SOCIAL}/ajax/application/{centre_slug}/book/request"
 
     def __str__(self) -> str:
-        """Return the underlying string value instead of the member name."""
+        """Return the URL string for direct use in HTTP requests."""
         return str(self.value)

pysportbot/service/booking.py

@@ -117,19 +117,23 @@ def schedule_bookings(
             logger.debug(f"Re-authenticating in {reauth_time:.2f} seconds.")
             time.sleep(reauth_time)
 
-        # Re-authenticate before booking
-        logger.info("Re-authenticating before booking.")
+        # Re-authenticate before booking if necessary
         try:
-            bot.login(config["email"], config["password"], config["centre"])
-        except Exception:
-            logger.warning("Re-authentication failed before booking execution.")
+            if bot._auth and bot._auth.is_session_valid():
+                logger.info("Session still valid. Skipping re-authentication.")
+            else:
+                logger.info("Attempting re-authenticating before booking.")
+                bot.login(config["email"], config["password"], config["centre"])
+
+        except Exception as e:
+            logger.warning(f"Re-authentication failed before booking execution with {e}.")
 
         # Wait the remaining time until execution
         now = datetime.now(pytz.timezone(time_zone))
         remaining_time = (execution_time - now).total_seconds()
         if remaining_time > 0:
             logger.info(f"Waiting {remaining_time:.2f} seconds until booking execution.")
-            time.sleep(remaining_time)
+        time.sleep(max(0, remaining_time))
 
     # Global booking delay
     if booking_delay > 0:

pysportbot/utils/errors.py

@@ -130,11 +130,6 @@ class ErrorMessages:
         """Return an error message for a failed login."""
         return "Login failed. Please check your credentials and try again."
 
-    @staticmethod
-    def failed_login_nubapp() -> str:
-        """Return an error message for a failed login to Nubapp."""
-        return "Login to Nubapp failed. Please try again later."
-
     @staticmethod
     def unknown_error(action: str) -> str:
         """Return an error message for an unknown error."""

pysportbot/utils/time.py

@@ -3,6 +3,25 @@ from datetime import datetime, time
 import pytz
 
 
+def get_day_bounds(date_string: str, fmt: str = "%Y-%m-%d", tz: str = "UTC") -> tuple[str, str]:
+    """
+    Get start and end bounds for a given date.
+
+    Args:
+        date_string (str): Date in specified format
+        fmt (str): Date format, defaults to "%Y-%m-%d"
+        tz (str): Timezone, defaults to "UTC"
+
+    Returns:
+        tuple: (start_timestamp, end_timestamp) as strings
+    """
+    tzinfo = pytz.timezone(tz)
+    date = datetime.strptime(date_string, fmt).replace(tzinfo=tzinfo)
+    start = datetime.combine(date.date(), time.min, tzinfo=tzinfo)
+    end = datetime.combine(date.date(), time.max, tzinfo=tzinfo)
+    return start.strftime(fmt), end.strftime(fmt)
+
+
 def get_unix_day_bounds(date_string: str, fmt: str = "%Y-%m-%d", tz: str = "UTC") -> tuple[int, int]:
     """
     Get the Unix timestamp bounds for a given day.

{pysportbot-0.0.16.dist-info → pysportbot-0.0.18.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pysportbot
-Version: 0.0.16
+Version: 0.0.18
 Summary: A python-based bot for automatic resasports slot booking
 Author: Joshua Falco Beirer
 Author-email: jbeirer@cern.ch

{pysportbot-0.0.16.dist-info → pysportbot-0.0.18.dist-info}/RECORD

@@ -1,12 +1,12 @@
-pysportbot/__init__.py,sha256=tZwOIuLO1-a3d4KKA5nNfXfN6PjJxem_hxyuff9utk4,6425
-pysportbot/activities.py,sha256=MATA0feSsDSoeFnHa4Y_dLv3gw4P6MFg-0kAEybqVIY,4991
-pysportbot/authenticator.py,sha256=t_5x9anmsfh0SwpN9JSemzqKv72Hwt__Q8mQBowIOIo,5183
-pysportbot/bookings.py,sha256=W91AYGPu0sCpGliuiVdlENsoGYzH8P6v-SyKisbSb7g,3127
+pysportbot/__init__.py,sha256=PdDUmkEBSOkdw3BaKMv1sXAUgYSTl6_qUOnAEj9UDBM,6570
+pysportbot/activities.py,sha256=fvj1Pnf3xxDuNY2FBGDOaach6tcZ_HJxCfoyGVju0oM,7598
+pysportbot/authenticator.py,sha256=MadHojTiDRcpPNABgT76j-fJ4cw9yydibHbEtDNktPg,7950
+pysportbot/bookings.py,sha256=yJPgCTECXBEVtQzwj3lUJ8QR3h43ycCUw80mTx-Ck60,3189
 pysportbot/centres.py,sha256=FTK-tXUOxiJvLCHP6Bk9XEQKODQZOwwkYLlioSJPBEk,3399
-pysportbot/endpoints.py,sha256=ANh5JAbdzyZQ-i4ODrhYlskPpU1gkBrw9UhMC7kRSvU,1353
+pysportbot/endpoints.py,sha256=vysTBx6fEn6LtjOlYx2Dj-LLe1ts7JmeEbFZiWcE5qU,1965
 pysportbot/service/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pysportbot/service/__main__.py,sha256=gsKfDMOmsVC3LHCQs0Dmp7YWJBlZeGcTsX-Mx4mk6ro,1496
-pysportbot/service/booking.py,sha256=oNLdY3nhs3ulAD-yFoc6YhgohbSN16xRYjEL8iyHkZg,5695
+pysportbot/service/booking.py,sha256=ifeo1LbtPvls-hpQOZW5TvoqeZ1MJxIipim4RHTH7nI,5908
 pysportbot/service/config_loader.py,sha256=t086yaAyAKkCJTpxedwhyJ7QqSf5XROGDzjrFLsUxJE,179
 pysportbot/service/config_validator.py,sha256=0P_pcXU7s3T3asODqFtv3mSp1HyPoVBphE4Qe1mxcps,2615
 pysportbot/service/scheduling.py,sha256=trz4zweZB2W9rwWAnW9Y6YkCo-f4dqtKyhaY_yqpJ-Y,2024
@@ -14,10 +14,10 @@ pysportbot/service/service.py,sha256=eW-roFozDzkK7kTzYbSzNwZhbZpBr-22yUrAHVnrD-0
 pysportbot/service/threading.py,sha256=j0tHgGty8iWDjpZtTzIu-5TUnDb9S6SJErm3QBpG-nY,1947
 pysportbot/session.py,sha256=pTQrz3bGzLYBtzVOgKv04l4UXDSgtA3Infn368bjg5I,1529
 pysportbot/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pysportbot/utils/errors.py,sha256=IRarfGtk1tETxUGAhPAIbeits_u2tJvVCGTtkHIdYFQ,5146
+pysportbot/utils/errors.py,sha256=hPbWJT_uOIgYjxqm5VojlRy3wWnFj9HLZGIcbv9tq8c,4956
 pysportbot/utils/logger.py,sha256=ANayMEeeAIVGKvITAxOFm2EdCbzBBTpNywuytAr4Z90,5366
-pysportbot/utils/time.py,sha256=VZSW8AxFIoFD5ZSmLUPcwawp6PmpkcxNjP3Db-Hl_fw,1244
-pysportbot-0.0.16.dist-info/LICENSE,sha256=6ov3DypdEVYpp2pn_B1MniKWO5C9iDA4O6PGcbork6c,1077
-pysportbot-0.0.16.dist-info/METADATA,sha256=vpDzfb3iMcE8y0_YCpbNDntjRA9Gn8bAym06HDe6D8I,8045
-pysportbot-0.0.16.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
-pysportbot-0.0.16.dist-info/RECORD,,
+pysportbot/utils/time.py,sha256=GKfFU5WwRSaWz2xNJ6EM0w1lHOVo8of5qhqnfh9xbJM,1926
+pysportbot-0.0.18.dist-info/LICENSE,sha256=6ov3DypdEVYpp2pn_B1MniKWO5C9iDA4O6PGcbork6c,1077
+pysportbot-0.0.18.dist-info/METADATA,sha256=sr_LZRcSuLIOIcHn43lr6_4vJS5A481Pv3NNs_LfdDc,8045
+pysportbot-0.0.18.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
+pysportbot-0.0.18.dist-info/RECORD,,