diff --git a/gd.json b/gd.json
new file mode 100644
index 0000000..5d6eb6b
--- /dev/null
+++ b/gd.json
@@ -0,0 +1,27 @@
+[
+ {
+ "id": 3628098,
+ "chargeId": null,
+ "partners": [],
+ "dateResa": "28\/03\/2024",
+ "startTime": "13:30",
+ "endTime": "15:00",
+ "dayFr": "jeudi 28 mars 2024",
+ "codeLiveXperience": null,
+ "qrCodeSpartime": null,
+ "sport": "Padel",
+ "court": "court 11",
+ "creaPartie": 0,
+ "limitCreaPartie": "2024-03-28 11:30:00",
+ "cancel": true,
+ "bloquerRemplacementJoueur": 1,
+ "canRemovePartners": false,
+ "remainingPlaces": 3,
+ "isCaptain": true,
+ "dtStart": "2024-03-28T13:30:00+01:00",
+ "garantieCb": null,
+ "dureeValidCertif": null,
+ "playerStatus": 3,
+ "products": []
+ }
+]
diff --git a/resa_padel/booking.py b/resa_padel/booking.py
index b5a58f1..64b1983 100644
--- a/resa_padel/booking.py
+++ b/resa_padel/booking.py
@@ -39,24 +39,12 @@ async def cancel_booking(club: Club, user: User, booking_filter: BookingFilter)
await service.cancel_booking(user, club, booking_filter)
-async def cancel_booking_id(club: Club, user: User, booking_id: int) -> None:
- """
- Cancel a booking that matches the booking id
-
- :param club: the club in which the booking was made
- :param user: the user who made the booking
- :param booking_id: the id of the booking to cancel
- """
- service = GestionSportsServices()
- await service.cancel_booking_id(user, club, booking_id)
-
-
async def get_tournaments(club: Club, user: User) -> list[Tournament]:
"""
- Cancel a booking that matches the booking id
+ Get the list of all current tournaments, their price, date and availability
- :param club: the club in which the booking was made
- :param user: the user who made the booking
+ :param club: the club in which the tournaments are
+ :param user: a user of the club in order to retrieve the information
"""
service = GestionSportsServices()
return await service.get_all_tournaments(user, club)
@@ -74,17 +62,23 @@ def main() -> tuple[Court, User] | list[Tournament] | None:
club = config.get_club()
users = config.get_users(club.id)
booking_filter = config.get_booking_filter()
+ LOGGER.info(
+ f"Booking a court of {booking_filter.sport_name} at {booking_filter.date} "
+ f"at club {club.name}"
+ )
court_booked, user = asyncio.run(book_court(club, users, booking_filter))
if court_booked:
LOGGER.info(
- "Court %s booked successfully at %s for user %s",
- court_booked,
- booking_filter.date,
- user,
+ f"Court of {booking_filter.sport_name} {court_booked} was booked "
+ f"successfully at {booking_filter.date} at club {club.name} "
+ f"for user {user}"
)
return court_booked, user
else:
- LOGGER.info("Booking did not work")
+ LOGGER.info(
+ f"No court of {booking_filter.sport_name} at {booking_filter.date} "
+ f"at club {club.name} was booked"
+ )
elif action == Action.CANCEL:
user = config.get_user()
diff --git a/resa_padel/exceptions.py b/resa_padel/exceptions.py
index 6a17281..b777616 100644
--- a/resa_padel/exceptions.py
+++ b/resa_padel/exceptions.py
@@ -1,2 +1,6 @@
-class ArgumentMissing(Exception):
+class WrongResponseStatus(Exception):
+ pass
+
+
+class MissingProperty(Exception):
pass
diff --git a/resa_padel/gestion_sport_connector.py b/resa_padel/gestion_sport_connector.py
index 55abcea..f7d1942 100644
--- a/resa_padel/gestion_sport_connector.py
+++ b/resa_padel/gestion_sport_connector.py
@@ -2,12 +2,11 @@ import asyncio
import json
import logging
from pathlib import Path
-from urllib.parse import urljoin
import config
from aiohttp import ClientResponse, ClientSession
-from bs4 import BeautifulSoup
-from models import Booking, BookingFilter, Club, Court, Sport, User
+from exceptions import WrongResponseStatus
+from models import BookingFilter, Club, Sport, User
from payload_builders import PayloadBuilder
from pendulum import DateTime
@@ -18,8 +17,8 @@ POST_HEADERS = config.get_post_headers("gestion-sports")
class GestionSportsConnector:
"""
- The connector for the Gestion Sports platform.
- It handles all the requests to the website.
+ The connector for the Gestion Sports platform handles all the HTTP requests to the
+ Gestion sports website.
"""
def __init__(self, club: Club):
@@ -35,184 +34,139 @@ class GestionSportsConnector:
self.club = club
- def _get_url_path(self, name: str) -> str:
- """
- Get the URL path for the service with the given name
-
- :param name: the name of the service
- :return: the URL path
- """
- self._check_url_path_exists(name)
-
- return urljoin(
- self.club.booking_platform.url,
- self.club.booking_platform.urls.get(name).path,
- )
-
- def _get_url_parameter(self, name: str) -> str:
- self._check_url_path_exists(name)
-
- return self.club.booking_platform.urls.get(name).parameter
-
- def _get_payload_template(self, name: str) -> Path:
- """
- Get the path to the template file for the service with the given name
-
- :param name: the name of the service
- :return: the path to the template file
- """
- self._check_payload_template_exists(name)
-
- return (
- config.get_resources_folder()
- / self.club.booking_platform.urls.get(name).payload_template
- )
-
- def _check_url_path_exists(self, name: str) -> None:
- """
- Check that the URL path for the given service is defined
-
- :param name: the name of the service
- """
- if (
- self.club.booking_platform.urls is None
- or self.club.booking_platform.urls.get(name) is None
- or self.club.booking_platform.urls.get(name).path is None
- ):
- raise ValueError(
- f"The booking platform internal URL path for page {name} of club "
- f"{self.club.name} are not set"
- )
-
- def _check_payload_template_exists(self, name: str) -> None:
- """
- Check that the payload template for the given service is defined
-
- :param name: the name of the service
- """
- if (
- self.club.booking_platform.urls is None
- or self.club.booking_platform.urls.get(name) is None
- or self.club.booking_platform.urls.get(name).path is None
- ):
- raise ValueError(
- f"The booking platform internal URL path for page {name} of club "
- f"{self.club.name} are not set"
- )
-
@property
def landing_url(self) -> str:
"""
- Get the URL to the landing page of Gestion-Sports
+ Get the URL to for landing to the website
- :return: the URL to the landing page
+ :return: the URL to landing
"""
- return self._get_url_path("landing-page")
+ return self.club.landing_url
@property
def login_url(self) -> str:
"""
- Get the URL to the connection login of Gestion-Sports
+ Get the URL to for logging in the website
- :return: the URL to the login page
+ :return: the URL for logging in
"""
- return self._get_url_path("login")
+ return self.club.login_url
@property
def login_template(self) -> Path:
"""
- Get the payload template to send to log in the website
+ Get the payload template for logging in the website
- :return: the payload template for logging in
+ :return: the payload template for logging
"""
- return self._get_payload_template("login")
+ return self.club.login_template
@property
def booking_url(self) -> str:
"""
- Get the URL to the booking page of Gestion-Sports
+ Get the URL used to book a court
- :return: the URL to the booking page
+ :return: the URL to book a court
"""
- return self._get_url_path("booking")
+ return self.club.booking_url
@property
def booking_template(self) -> Path:
"""
- Get the payload template to send to book a court
+ Get the payload template for booking a court
:return: the payload template for booking a court
"""
- return self._get_payload_template("booking")
+ return self.club.booking_template
@property
def user_bookings_url(self) -> str:
"""
- Get the URL where all the user's bookings are available
+ Get the URL of the bookings related to a user that are not yet passed
- :return: the URL to the user's bookings
+ :return: the URL to get the bookings related to a user
"""
- return self._get_url_path("user-bookings")
+ return self.club.user_bookings_url
@property
def user_bookings_template(self) -> Path:
"""
- Get the payload template to send to get all the user's bookings that are
- available
+ Get the payload template to get the bookings related to a user that are not yet
+ passed
- :return: the payload template for the user's bookings
+ :return: the template for requesting the bookings related to a user
"""
- return self._get_payload_template("user-bookings")
+ return self.club.user_bookings_template
@property
- def booking_cancellation_url(self) -> str:
+ def cancel_url(self) -> str:
"""
- Get the URL where all the user's bookings are available
+ Get the URL used to cancel a booking
- :return: the URL to the user's bookings
+ :return: the URL to cancel a booking
"""
- return self._get_url_path("cancellation")
+ return self.club.cancel_url
@property
- def booking_cancel_template(self) -> Path:
+ def cancel_template(self) -> Path:
"""
- Get the payload template to send to get all the user's bookings that are
- available
+ Get the payload template for cancelling a booking
- :return: the payload template for the user's bookings
+ :return: the template for cancelling a booking
"""
- return self._get_payload_template("cancellation")
+ return self.club.cancel_template
@property
- def tournaments_sessions_url(self) -> str:
- return self._get_url_path("tournament-sessions")
+ def sessions_url(self) -> str:
+ """
+ Get the URL of the session containing all the tournaments
+
+ :return: the URL to get the session
+ """
+ return self.club.sessions_url
@property
- def tournaments_sessions_template(self) -> Path:
- return self._get_payload_template("tournament-sessions")
+ def sessions_template(self) -> Path:
+ """
+ Get the payload template for requesting the session containing all the
+ tournaments
+
+ :return: the template for requesting the session
+ """
+ return self.club.sessions_template
@property
- def tournaments_list_url(self) -> str:
- return self._get_url_path("tournaments-list")
+ def tournaments_url(self) -> str:
+ """
+ Get the URL of all the tournaments list
+
+ :return: the URL to get the tournaments list
+ """
+ return self.club.tournaments_url
@property
- def available_sports(self) -> dict[str, Sport]:
+ def sports(self) -> dict[str, Sport]:
"""
Get a dictionary of all sports, the key is the sport name lowered case
:return: the dictionary of all sports
"""
- return {
- sport.name.lower(): sport for sport in self.club.booking_platform.sports
- }
+ return self.club.sports
+
+ @staticmethod
+ def check_response_status(response_status: int) -> None:
+ if response_status != 200:
+ raise WrongResponseStatus("GestionSports request failed")
async def land(self, session: ClientSession) -> ClientResponse:
"""
Perform the request to the landing page in order to get the cookie PHPSESSIONID
+ :param session: the client session shared among all connections
:return: the response from the landing page
"""
LOGGER.info("Connecting to GestionSports API at %s", self.login_url)
async with session.get(self.landing_url) as response:
+ self.check_response_status(response.status)
await response.text()
return response
@@ -220,6 +174,8 @@ class GestionSportsConnector:
"""
Perform the request to the log in the user
+ :param session: the client session shared among all connections
+ :param user: the user to log in
:return: the response from the login
"""
LOGGER.info("Logging in to GestionSports API at %s", self.login_url)
@@ -228,11 +184,12 @@ class GestionSportsConnector:
async with session.post(
self.login_url, data=payload, headers=POST_HEADERS, allow_redirects=False
) as response:
+ self.check_response_status(response.status)
resp_text = await response.text()
LOGGER.debug("Connexion request response:\n%s", resp_text)
return response
- async def book_any_court(
+ async def send_all_booking_requests(
self, session: ClientSession, booking_filter: BookingFilter
) -> list[tuple[int, dict]]:
"""
@@ -241,7 +198,7 @@ class GestionSportsConnector:
The gestion-sports backend does not allow several bookings at the same time
so there is no need to make each request one after the other
- :param session: the session to use
+ :param session: the client session shared among all connections
:param booking_filter: the booking conditions to meet
:return: the booked court, or None if no court was booked
"""
@@ -249,7 +206,7 @@ class GestionSportsConnector:
"Booking any available court from GestionSports API at %s", self.booking_url
)
- sport = self.available_sports.get(booking_filter.sport_name)
+ sport = self.sports.get(booking_filter.sport_name)
bookings = await asyncio.gather(
*[
@@ -274,7 +231,7 @@ class GestionSportsConnector:
"""
Book a single court that meets the conditions from the booking filter
- :param session: the HTTP session that contains the user information and cookies
+ :param session: the client session shared among all connections
:param date: the booking date
:param court_id: the id of the court to book
:param sport_id: the id of the sport
@@ -293,168 +250,96 @@ class GestionSportsConnector:
async with session.post(
self.booking_url, data=payload, headers=POST_HEADERS
) as response:
- assert response.status == 200
+ self.check_response_status(response.status)
resp_json = json.loads(await response.text())
+
LOGGER.debug("Response from booking request:\n'%s'", resp_json)
return court_id, resp_json
- def get_booked_court(
- self, bookings: list[tuple[int, dict]], sport_name: str
- ) -> Court | None:
+ async def send_hash_request(self, session: ClientSession) -> ClientResponse:
"""
- Parse the booking list and return the court that was booked
+ Get the hash value used in some other requests
- :param bookings: a list of bookings
- :param sport_name: the sport name
- :return: the id of the booked court if any, None otherwise
- """
- for court_id, response in bookings:
- if self.is_booking_response_status_ok(response):
- LOGGER.debug("Court %d is booked", court_id)
- court_booked = self.find_court(court_id, sport_name)
- LOGGER.info("Court '%s' is booked", court_booked.name)
- return court_booked
- LOGGER.debug("No booked court found")
- return None
-
- def find_court(self, court_id: int, sport_name: str) -> Court:
- """
- Get all the court information based on the court id and the sport name
-
- :param court_id: the court id
- :param sport_name: the sport name
- :return: the court that has the given id and sport name
- """
- sport = self.available_sports.get(sport_name.lower())
- for court in sport.courts:
- if court.id == court_id:
- return court
-
- @staticmethod
- def is_booking_response_status_ok(response: dict) -> bool:
- """
- Check if the booking response is OK
-
- :param response: the response as a string
- :return: true if the status is ok, false otherwise
- """
- return response["status"] == "ok"
-
- async def get_ongoing_bookings(self, session: ClientSession) -> list[Booking]:
- """
- Get the list of all ongoing bookings of a user.
- The steps to perform this are to get the user's bookings page and get a hidden
- property in the HTML to get a hash that will be used in the payload of the
- POST request (sic) to get the user's bookings.
- Gestion sports is really a mess!!
-
- :return: the list of all ongoing bookings of a user
- """
- hash_value = await self.send_hash_request(session)
- LOGGER.debug(f"Hash value: {hash_value}")
- payload = PayloadBuilder.build(self.user_bookings_template, hash=hash_value)
- LOGGER.debug(f"Payload to get ongoing bookings: {payload}")
- return await self.send_user_bookings_request(session, payload)
-
- async def send_hash_request(self, session: ClientSession) -> str:
- """
- Get the hash value used in the request to get the user's bookings
-
- :param session: the session in which the user logged in
+ :param session: the client session shared among all connections
:return: the value of the hash
"""
async with session.get(self.user_bookings_url) as response:
+ self.check_response_status(response.status)
html = await response.text()
LOGGER.debug("Get bookings response: %s\n", html)
- return self.get_hash_input(html)
-
- @staticmethod
- def get_hash_input(html_doc: str) -> str:
- """
- There is a secret hash generated by Gestion sports that is reused when trying to get
- users bookings. This hash is stored in a hidden input with name "mesresas-hash"
-
- :param html_doc: the html document when getting the page mes-resas.html
- :return: the value of the hash in the page
- """
- soup = BeautifulSoup(html_doc, "html.parser")
- inputs = soup.find_all("input")
- for input_tag in inputs:
- if input_tag.get("name") == "mesresas-hash":
- return input_tag.get("value").strip()
+ return response
async def send_user_bookings_request(
- self, session: ClientSession, payload: str
- ) -> list[Booking]:
+ self, session: ClientSession, hash_value: str
+ ) -> ClientResponse:
"""
- Perform the HTTP request to get all bookings
+ Send a request to the platform to get all bookings of a user
- :param session: the session in which the user logged in
- :param payload: the HTTP payload for the request
+ :param session: the client session shared among all connections
+ :param hash_value: the hash value to put in the payload
:return: a dictionary containing all the bookings
"""
+
+ payload = PayloadBuilder.build(self.user_bookings_template, hash=hash_value)
async with session.post(
self.user_bookings_url, data=payload, headers=POST_HEADERS
) as response:
- resp = await response.text()
- LOGGER.debug("ongoing bookings response: %s\n", resp)
- return [Booking(**booking) for booking in json.loads(resp)]
+ self.check_response_status(response.status)
+ await response.text()
+ return response
- async def cancel_booking_id(
- self, session: ClientSession, booking_id: int
+ async def send_cancellation_request(
+ self, session: ClientSession, booking_id: int, hash_value: str
) -> ClientResponse:
"""
Send the HTTP request to cancel the booking
- :param session: the HTTP session that contains the user information and cookies
+ :param session: the client session shared among all connections
:param booking_id: the id of the booking to cancel
:return: the response from the client
"""
- hash_value = await self.send_hash_request(session)
-
payload = PayloadBuilder.build(
- self.booking_cancel_template,
+ self.cancel_template,
booking_id=booking_id,
hash=hash_value,
)
async with session.post(
- self.booking_cancellation_url, data=payload, headers=POST_HEADERS
+ self.cancel_url, data=payload, headers=POST_HEADERS
) as response:
+ self.check_response_status(response.status)
await response.text()
return response
- async def cancel_booking(
- self, session: ClientSession, booking_filter: BookingFilter
- ) -> ClientResponse | None:
+ async def send_session_request(self, session: ClientSession) -> ClientResponse:
"""
- Cancel the booking that meets some conditions
+ Send a request to the platform to get the session id
- :param session: the session
- :param booking_filter: the conditions the booking to cancel should meet
+ :param session: the client session shared among all connections
+ :return: a client response containing HTML which has the session id
"""
- bookings = await self.get_ongoing_bookings(session)
-
- for booking in bookings:
- if booking.matches(booking_filter):
- return await self.cancel_booking_id(session, booking.id)
-
- async def send_tournaments_sessions_request(
- self, session: ClientSession
- ) -> ClientResponse:
- payload = self.tournaments_sessions_template.read_text()
+ payload = self.sessions_template.read_text()
async with session.post(
- self.tournaments_sessions_url, data=payload, headers=POST_HEADERS
+ self.sessions_url, data=payload, headers=POST_HEADERS
) as response:
+ self.check_response_status(response.status)
LOGGER.debug("tournament sessions: \n%s", await response.text())
return response
async def send_tournaments_request(
- self, session: ClientSession, tournement_session_id: str
+ self, session: ClientSession, session_id: str
) -> ClientResponse:
- final_url = self.tournaments_list_url + tournement_session_id
+ """
+ Send a request to the platform to get the next tournaments
+
+ :param session: the client session shared among all connections
+ :param session_id: the tournaments are grouped in a session
+ :return: a client response containing the list of all the nex tournaments
+ """
+ final_url = self.tournaments_url + session_id
LOGGER.debug("Getting tournaments list at %s", final_url)
async with session.get(final_url) as response:
+ self.check_response_status(response.status)
LOGGER.debug("tournaments: %s\n", await response.text())
return response
diff --git a/resa_padel/gestion_sports_services.py b/resa_padel/gestion_sports_services.py
index d616484..6aa8f19 100644
--- a/resa_padel/gestion_sports_services.py
+++ b/resa_padel/gestion_sports_services.py
@@ -6,16 +6,24 @@ import pendulum
from aiohttp import ClientSession
from bs4 import BeautifulSoup
from gestion_sport_connector import GestionSportsConnector
-from models import BookingFilter, BookingOpening, Club, Court, Tournament, User
+from models import (
+ Booking,
+ BookingFilter,
+ BookingOpening,
+ Club,
+ Court,
+ Sport,
+ Tournament,
+ User,
+)
from pendulum import DateTime
LOGGER = logging.getLogger(__name__)
class GestionSportsServices:
- @staticmethod
async def book(
- club: Club, user: User, booking_filter: BookingFilter
+ self, club: Club, user: User, booking_filter: BookingFilter
) -> Court | None:
"""
Perform a request for each court at the same time to increase the chances to get
@@ -45,37 +53,76 @@ class GestionSportsServices:
booking_filter, booking_opening
)
- bookings = await connector.book_any_court(session, booking_filter)
+ bookings = await connector.send_all_booking_requests(
+ session, booking_filter
+ )
LOGGER.debug("Booking results:\n'%s'", bookings)
- return connector.get_booked_court(bookings, booking_filter.sport_name)
+
+ sport = club.sports.get(booking_filter.sport_name)
+
+ return self.get_booked_court(bookings, sport)
+
+ def get_booked_court(
+ self, bookings: list[tuple[int, dict]], sport: Sport
+ ) -> Court | None:
+ """
+ Parse the booking list and return the court that was booked
+
+ :param bookings: a list of bookings
+ :param sport: the sport of the club and all the courts it has
+ :return: the id of the booked court if any, None otherwise
+ """
+ for court_id, response in bookings:
+ if self.is_booking_response_status_ok(response):
+ LOGGER.debug("Court %d is booked", court_id)
+ court_booked = self.find_court(court_id, sport)
+ LOGGER.info("Court '%s' is booked", court_booked.name)
+ return court_booked
+ LOGGER.debug("No booked court found")
+ return None
@staticmethod
- async def has_user_available_slots(user: User, club: Club) -> bool:
+ def is_booking_response_status_ok(response: dict) -> bool:
+ """
+ Check if the booking response is OK
+
+ :param response: the response as a string
+ :return: true if the status is ok, false otherwise
+ """
+ return response["status"] == "ok"
+
+ @staticmethod
+ def find_court(court_id: int, sport: Sport) -> Court:
+ """
+ Get all the court information based on the court id and the sport name
+
+ :param court_id: the court id
+ :param sport: the sport
+ :return: the court that has the given id and sport name
+ """
+ for court in sport.courts:
+ if court.id == court_id:
+ return court
+
+ async def has_user_available_slots(self, user: User, club: Club) -> bool:
+ """
+ Checks if a user has available booking slot.
+ If a user already has an ongoing booking, it is considered as no slot is
+ available
+
+ :param user: The user to check the booking availability
+ :param club: The club of the user
+ :return: True if the user has no ongoing booking, False otherwise
+ """
connector = GestionSportsConnector(club)
async with ClientSession() as session:
await connector.land(session)
await connector.login(session, user)
- bookings = await connector.get_ongoing_bookings(session)
+ bookings = await self.get_ongoing_bookings(session, connector)
return bool(bookings)
- @staticmethod
- async def cancel_booking(user: User, club: Club, booking_filter: BookingFilter):
- connector = GestionSportsConnector(club)
- async with ClientSession() as session:
- await connector.land(session)
- await connector.login(session, user)
- await connector.cancel_booking(session, booking_filter)
-
- @staticmethod
- async def cancel_booking_id(user: User, club: Club, booking_id: int):
- connector = GestionSportsConnector(club)
- async with ClientSession() as session:
- await connector.land(session)
- await connector.login(session, user)
- await connector.cancel_booking_id(session, booking_id)
-
@staticmethod
def wait_until_booking_time(
booking_filter: BookingFilter, booking_opening: BookingOpening
@@ -128,6 +175,71 @@ class GestionSportsServices:
return booking_date.at(booking_hour, booking_minute)
+ async def cancel_booking(
+ self, user: User, club: Club, booking_filter: BookingFilter
+ ):
+ connector = GestionSportsConnector(club)
+ async with ClientSession() as session:
+ await connector.land(session)
+ await connector.login(session, user)
+
+ bookings = await self.get_ongoing_bookings(session, connector)
+ for booking in bookings:
+ if booking.matches(booking_filter):
+ return await self.cancel_booking_id(session, connector, booking.id)
+
+ async def get_ongoing_bookings(
+ self, session: ClientSession, connector: GestionSportsConnector
+ ) -> list[Booking]:
+ """
+ Get the list of all ongoing bookings of a user.
+ The steps to perform this are to get the user's bookings page and get a hidden
+ property in the HTML to get a hash that will be used in the payload of the
+ POST request (sic) to get the user's bookings.
+ Gestion sports is really a mess!!
+
+ :param session: the client session shared among all connections
+ :param connector: the connector used to send the requests
+ :return: the list of all ongoing bookings of a user
+ """
+ response = await connector.send_hash_request(session)
+ hash_value = self.get_hash_input(await response.text())
+ LOGGER.debug(f"Hash value: {hash_value}")
+ response = await connector.send_user_bookings_request(session, hash_value)
+ return [Booking(**booking) for booking in json.loads(await response.text())]
+
+ @staticmethod
+ def get_hash_input(html_doc: str) -> str:
+ """
+ There is a secret hash generated by Gestion sports that is reused when trying to get
+ users bookings. This hash is stored in a hidden input with name "mesresas-hash"
+
+ :param html_doc: the html document when getting the page mes-resas.html
+ :return: the value of the hash in the page
+ """
+ soup = BeautifulSoup(html_doc, "html.parser")
+ inputs = soup.find_all("input")
+ for input_tag in inputs:
+ if input_tag.get("name") == "mesresas-hash":
+ return input_tag.get("value").strip()
+
+ async def cancel_booking_id(
+ self, session: ClientSession, connector: GestionSportsConnector, booking_id: int
+ ) -> None:
+ """
+ Send the HTTP request to cancel the booking
+
+ :param session: the client session shared among all connections
+ :param connector: the connector used to send the requests
+ :param booking_id: the id of the booking to cancel
+ :return: the response from the client
+ """
+ response = await connector.send_hash_request(session)
+ hash_value = self.get_hash_input(await response.text())
+ LOGGER.debug(f"Hash value: {hash_value}")
+
+ await connector.send_cancellation_request(session, booking_id, hash_value)
+
@staticmethod
async def get_all_tournaments(user: User, club: Club) -> list[Tournament]:
connector = GestionSportsConnector(club)
@@ -135,7 +247,7 @@ class GestionSportsServices:
await connector.land(session)
await connector.login(session, user)
- session_html = await connector.send_tournaments_sessions_request(session)
+ session_html = await connector.send_session_request(session)
tournaments_id = GestionSportsServices.retrieve_tournament_session(
await session_html.text()
)
diff --git a/resa_padel/models.py b/resa_padel/models.py
index 1fbb39c..4180fb4 100644
--- a/resa_padel/models.py
+++ b/resa_padel/models.py
@@ -1,7 +1,11 @@
from enum import Enum
+from pathlib import Path
from typing import Optional
+from urllib.parse import urljoin
+import config
import pendulum
+from exceptions import MissingProperty
from pendulum import Date, Time
from pydantic import BaseModel, ConfigDict, Field, field_validator
from pydantic_extra_types.pendulum_dt import DateTime
@@ -84,6 +88,166 @@ class BookingPlatform(BaseModel):
sports: list[Sport]
urls: dict[str, Url]
+ def get_url_path(self, name: str) -> str:
+ """
+ Get the URL path for the service with the given name
+
+ :param name: the name of the service
+ :return: the URL path
+ """
+ self.check_url_path_exists(name)
+
+ return urljoin(self.url, self.urls.get(name).path)
+
+ def get_payload_template(self, name: str) -> Path:
+ """
+ Get the path to the template file for the service with the given name
+
+ :param name: the name of the service
+ :return: the path to the template file
+ """
+ self.check_payload_template_exists(name)
+
+ return config.get_resources_folder() / self.urls.get(name).payload_template
+
+ def get_url_parameter(self, name: str) -> str:
+ self.check_url_path_exists(name)
+
+ return self.urls.get(name).parameter
+
+ def check_url_path_exists(self, name: str) -> None:
+ """
+ Check that the URL path for the given service is defined
+
+ :param name: the name of the service
+ """
+ if (
+ self.urls is None
+ or self.urls.get(name) is None
+ or self.urls.get(name).path is None
+ ):
+ raise MissingProperty(
+ f"The booking platform internal URL path for page {name} are not set"
+ )
+
+ def check_payload_template_exists(self, name: str) -> None:
+ """
+ Check that the payload template for the given service is defined
+
+ :param name: the name of the service
+ """
+ if (
+ self.urls is None
+ or self.urls.get(name) is None
+ or self.urls.get(name).path is None
+ ):
+ raise ValueError(
+ f"The booking platform internal URL path for page {name} are not set"
+ )
+
+ @property
+ def landing_url(self) -> str:
+ """
+ Get the URL to the landing page of Gestion-Sports
+
+ :return: the URL to the landing page
+ """
+ return self.get_url_path("landing-page")
+
+ @property
+ def login_url(self) -> str:
+ """
+ Get the URL to the connection login of Gestion-Sports
+
+ :return: the URL to the login page
+ """
+ return self.get_url_path("login")
+
+ @property
+ def login_template(self) -> Path:
+ """
+ Get the payload template to send to log in the website
+
+ :return: the payload template for logging in
+ """
+ return self.get_payload_template("login")
+
+ @property
+ def booking_url(self) -> str:
+ """
+ Get the URL to the booking page of Gestion-Sports
+
+ :return: the URL to the booking page
+ """
+ return self.get_url_path("booking")
+
+ @property
+ def booking_template(self) -> Path:
+ """
+ Get the payload template to send to book a court
+
+ :return: the payload template for booking a court
+ """
+ return self.get_payload_template("booking")
+
+ @property
+ def user_bookings_url(self) -> str:
+ """
+ Get the URL where all the user's bookings are available
+
+ :return: the URL to the user's bookings
+ """
+ return self.get_url_path("user-bookings")
+
+ @property
+ def user_bookings_template(self) -> Path:
+ """
+ Get the payload template to send to get all the user's bookings that are
+ available
+
+ :return: the payload template for the user's bookings
+ """
+ return self.get_payload_template("user-bookings")
+
+ @property
+ def booking_cancellation_url(self) -> str:
+ """
+ Get the URL where all the user's bookings are available
+
+ :return: the URL to the user's bookings
+ """
+ return self.get_url_path("cancellation")
+
+ @property
+ def booking_cancel_template(self) -> Path:
+ """
+ Get the payload template to send to get all the user's bookings that are
+ available
+
+ :return: the payload template for the user's bookings
+ """
+ return self.get_payload_template("cancellation")
+
+ @property
+ def tournaments_sessions_url(self) -> str:
+ return self.get_url_path("tournament-sessions")
+
+ @property
+ def tournaments_sessions_template(self) -> Path:
+ return self.get_payload_template("tournament-sessions")
+
+ @property
+ def tournaments_list_url(self) -> str:
+ return self.get_url_path("tournaments-list")
+
+ @property
+ def available_sports(self) -> dict[str, Sport]:
+ """
+ Get a dictionary of all sports, the key is the sport name lowered case
+ :return: the dictionary of all sports
+ """
+ return {sport.name.lower(): sport for sport in self.sports}
+
class Club(BaseModel):
id: str
@@ -91,6 +255,109 @@ class Club(BaseModel):
url: str
booking_platform: BookingPlatform = Field(alias="bookingPlatform")
+ @property
+ def landing_url(self) -> str:
+ """
+ Get the URL to the landing page of Gestion-Sports
+
+ :return: the URL to the landing page
+ """
+ return self.booking_platform.landing_url
+
+ @property
+ def login_url(self) -> str:
+ """
+ Get the URL to the connection login of Gestion-Sports
+
+ :return: the URL to the login page
+ """
+ return self.booking_platform.login_url
+
+ @property
+ def login_template(self) -> Path:
+ """
+ Get the payload template to send to log in the website
+
+ :return: the payload template for logging in
+ """
+ return self.booking_platform.login_template
+
+ @property
+ def booking_url(self) -> str:
+ """
+ Get the URL to the booking page of Gestion-Sports
+
+ :return: the URL to the booking page
+ """
+ return self.booking_platform.booking_url
+
+ @property
+ def booking_template(self) -> Path:
+ """
+ Get the payload template to send to book a court
+
+ :return: the payload template for booking a court
+ """
+ return self.booking_platform.booking_template
+
+ @property
+ def user_bookings_url(self) -> str:
+ """
+ Get the URL where all the user's bookings are available
+
+ :return: the URL to the user's bookings
+ """
+ return self.booking_platform.user_bookings_url
+
+ @property
+ def user_bookings_template(self) -> Path:
+ """
+ Get the payload template to send to get all the user's bookings that are
+ available
+
+ :return: the payload template for the user's bookings
+ """
+ return self.booking_platform.user_bookings_template
+
+ @property
+ def cancel_url(self) -> str:
+ """
+ Get the URL where all the user's bookings are available
+
+ :return: the URL to the user's bookings
+ """
+ return self.booking_platform.booking_cancellation_url
+
+ @property
+ def cancel_template(self) -> Path:
+ """
+ Get the payload template to send to get all the user's bookings that are
+ available
+
+ :return: the payload template for the user's bookings
+ """
+ return self.booking_platform.booking_cancel_template
+
+ @property
+ def sessions_url(self) -> str:
+ return self.booking_platform.tournaments_sessions_url
+
+ @property
+ def sessions_template(self) -> Path:
+ return self.booking_platform.tournaments_sessions_template
+
+ @property
+ def tournaments_url(self) -> str:
+ return self.booking_platform.tournaments_list_url
+
+ @property
+ def sports(self) -> dict[str, Sport]:
+ """
+ Get a dictionary of all sports, the key is the sport name lowered case
+ :return: the dictionary of all sports
+ """
+ return self.booking_platform.available_sports
+
class PlatformDefinition(BaseModel):
id: str
diff --git a/tests/data/responses/tournament-sessions.html b/tests/data/responses/tournament-sessions.html
deleted file mode 100644
index ff61262..0000000
--- a/tests/data/responses/tournament-sessions.html
+++ /dev/null
@@ -1,1380 +0,0 @@
-
-
-
-
-
- Home
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- Gestion Sports est une plateforme de services internet à destination de Clubs de sport, clients de la société Gestion Sports.
- Les présentes Conditions Générales de Vente (CGV) ont pour objet de définir les termes et conditions qui s’imposent à toute personne physique qui souscrit à un abonnement proposé par le Club sur la Plateforme.
-
-
-
DEFINITIONS
-
- Le terme « Club » vise exclusivement les personnes physiques ou morales qui sont clients de la société Gestion Sports et qui ont accès à l’interface spécifique des dirigeants de club.
- Le terme « Bon de commande » désigne le formulaire d’inscription en format électronique permettant la souscription d’un Abonnement.
- Le terme « Utilisateur » désigne toute personne physique qui effectue une souscription d’un abonnement, un achat de crédits, une inscription à un événement payant ou bien une location de terrains en application des présentes Conditions Générales.
-
-
ARTICLE 1 - CONDITIONS D’ACCES AUX ACHATS
-
- 1.1. Pour bénéficier des services du Club, l’Utilisateur doit procéder à son inscription exclusivement sur le site internet ou sur l’application du Club.
- 1.2. Tout Utilisateur déclare avoir la capacité d’accepter les CGV, c’est-à-dire avoir la majorité numérique légale et ne pas être sous tutelle ou curatelle.
-
- Dans l’hypothèse où l’Utilisateur serait une personne physique ne jouissant pas de la majorité numérique légale,
- il déclare et reconnaît avoir recueilli l’autorisation auprès de ses parents ou du (des) titulaire(s) de l’autorité parentale le concernant pour
- s’inscrire sur la Plateforme. Ainsi, les parents (ou titulaires de l’autorité parentale) sont invités à surveiller l’utilisation faite par leurs enfants de la Plateforme
- et à garder présent à l’esprit qu’en leur qualité de tuteur légal il est de leur responsabilité de surveiller l’utilisation qui en est faite.
- Toute demande d’inscription générée automatiquement par un robot ou par toute autre méthode sera refusée..
-
- 1.2. L’Utilisateur doit créer un compte sur l’application du club ou sur le lien personnalisé communiqué par le club. À cette fin, il doit renseigner les différents champs du formulaire d’inscription et notamment une adresse e-mail valide et, le cas échéant, un numéro de téléphone.
- Une fois son inscription validée, la plateforme de réservation adresse à l’Utilisateur un courrier électronique de confirmation en utilisant l’adresse email du Club.
-
- 1.3. Lorsqu’il renseigne le formulaire d’inscription, l’Utilisateur s’engage à remplir correctement ledit formulaire,
- et notamment à ne communiquer que des informations exactes, à jour et complètes.
-
- 1.4. L’Utilisateur est entièrement et exclusivement responsable de l’usage de la Plateforme par lui-même et par tout tiers quel qu’il soit.
- Toute connexion ou transmission de données effectuée en utilisant la Plateforme sera réputée avoir été effectuée par l’Utilisateur et sous sa responsabilité exclusive.
-
- 1.5. La société Gestion Sports ne pourra être tenu responsable si les données relatives à l’inscription d’un Utilisateur ne lui parvenaient pas pour une quelconque raison qui ne lui serait pas imputable
- (par exemple, un problème de connexion à Internet dû à une quelconque raison chez l’Utilisateur,
- une défaillance momentanée de ses serveurs, etc) ou lui arrivaient illisibles ou impossibles à traiter,
- (par exemple si l’Utilisateur possède un matériel informatique ou un environnement logiciel inadéquat pour son inscription).
-
- 1.6. La souscription d’un Abonnement, l’achat de crédits, l'inscription à un événement payant ou bien la location de terrains s’effectuent en ligne sur le Site ou l’application du Club
- par saisie des données personnelles et informations de paiement demandées et après validation par l’Utilisateur de ses données. Ceci constitue le Bon de commande.
-
- 1.7. L’Utilisateur doit consulter et adhérer sans réserve aux présentes CGV en cochant la case située à côté de la mention « J’ai lu et j’accepte sans réserve les conditions générales de vente».
-
-
-
-
ARTICLE 2 - TARIF ET PAIEMENT DES ACHATS
-
- 2.1. Les tarifs sont consultables en ligne.
-
- 2.2. Le paiement s’effectue par CB ou VISA, en saisissant les coordonnées, le cryptogramme visuel et la date d’expiration de sa carte bancaire.
-
- 2.3. Une fois le paiement en ligne effectif et validé par la banque, l’Utilisateur recevra une confirmation par mail avec toutes les données enregistrées concernant sa commande.
-
- 2.4. L’Utilisateur autorise le Club et la plateforme à conserver ses informations bancaires uniquement pour effectuer automatiquement les paiements par carte bancaire suivants lorsque la reconduction tacite de l’abonnement est prévue.
-
- 2.5. De même, l’Utilisateur peut autoriser le Club et la plateforme à conserver ses informations bancaires pour faciliter les prochains paiements en ligne en cochant la case située à côté de la mention « J’autorise la conservation de mes informations bancaires pour faciliter les prochains paiements ».
-
-
-
ARTICLE 3 - DUREE DE L’ABONNEMENT
-
- 3.1. Les abonnements sont souscrits pour la durée initiale déterminée sur le Bon de Commande.
-
-
-
ARTICLE 4 - DROIT DE RETRACTATION
-
- Conformément au Code de la consommation, l’Utilisateur peut exercer son droit de rétractation dans un délai de 14 jours suivant la date de commande en adressant au Club par courrier RAR, exprimant clairement sa volonté de se rétracter.
- Le remboursement de l’Utilisateur s’effectuera à réception du courrier RAR.
-
-
-
ARTICLE 5 - RESILIATION PAR LE CLUB
-
- 5.1. En cas :
- a) d’absence de règlement d’une facture ;
- b) de violation par l’Utilisateur du périmètre des droits qui lui sont concédés en application de son Abonnement ou de son Achat ;
- c) de tentative d’intrusion, d’atteinte à l’intégrité logicielle ou de contrefaçon des sites internet et Services de Gestion Sports par l’Utilisateur;
-
- Le Club peut à sa seule discrétion :
- - suspendre l’accès au Service, sans notification préalable à l’Utilisateur ,
- et/ou
- - prononcer la résiliation de l’Abonnement, de plein droit à l’expiration d’un préavis de 15 jours après envoi d’une mise en demeure par lettre recommandé avec demande d’avis de réception.
-
- 5.2. Dans tous les cas ci-avant, toutes les sommes restant dues par l'Utilisateur seront immédiatement exigibles sans préjudice des dommages et intérêts qui pourraient être dus au Club.
-
-
-
ARTICLE 6 - INCESSIBILITE
-
- L'Utilisateur ne peut céder tout ou partie des droits et obligations résultant des présentes à un tiers, sans l'autorisation expresse et préalable du Club.
-
-
-
ARTICLE 7 - ACCÈS AUX INFORMATIONS PERSONNELLES
-
- 7.1. Les Informations Personnelles sont accessibles à tout moment dans la rubrique « Mon Compte » grâce à l’adresse e-mail et au mot de passe de l’Utilisateur.
-
- 7.2. Conformément à la loi n°78-17 du 6 janvier 1978 relative à l’informatique, aux fichiers et aux libertés, modifiée par la loi n°2004-801 du 6 août 2004 (la « loi Informatique et Libertés »),
- l’Utilisateur dispose d’un droit d’accès, de rectification, de suppression et d’opposition relatif aux Informations Personnelles le concernant. Pour l’exercer, celui-ci peut se connecter à son compte ou contacter directement son club.
-
- 7.3. Toutes les Informations Personnelles sont envoyées et stockées chez l’hébergeur du site gestion-sports.fr situé en France, dont les cordonnées figurent sur la page d’accueil à la rubrique « Mentions Légales ».
-
- 7.4. Les Informations Personnelles ne seront conservées que pour la durée strictement nécessaire à la gestion de la relation client et prospect et ne dépassant pas la durée durant laquelle le Compte Gestion Sports de l’Utilisateur sera actif.
-
-
-
ARTICLE 8 - DOCUMENTS CONTRACTUELS
-
- 8.1. Les documents contractuels constituant les contrats de vente sont par ordre de priorité :
- -le Bon de Commande
- -les présentes Conditions Générales
-
- En cas de contradiction entre les différents documents, le document de rang supérieur prévaudra.
-
- 8.2. Le Club se réserve le droit de modifier, à tout moment, le contenu des Conditions Générales. De telles modifications donnent lieu à l’édition d’une nouvelle version qui s’appliquera automatiquement aux achats effectués ultérieurement.
-
-
-
ARTICLE 9 - LOI APPLICABLE ET JURIDICTION COMPETENTE
-
- Les présentes Conditions Générales sont soumises au droit français. En cas de litige, les tribunaux français seront seuls compétents.
- Les Parties s’engagent cependant à rechercher une solution amiable avant toute action judiciaire.
-
-
-
-
-
Annexe – Formulaire de rétractation (Vente à distance)
-
- Le consommateur dispose de 14 jours pour renoncer à son engagement par lettre recommandée
- avec accusé de réception (LRAR) à partir de la conclusion du contrat.
- Si le jour d'expiration du délai est un samedi,
- un dimanche ou un jour férié ou chômé, le délai est prolongé jusqu'au lundi ou le lendemain du jour férié.
-
-
- À l'attention de .................................. (Nom du Club) , Je notifie par la présente ma rétractation du contrat d’abonnement ci-dessous :
-
-
- Numéro du contrat ou de la commande:
-
-
- Nom et prénom de l’abonné:
-
-
- Signature de l’abonné
-
- A imprimer et à adresser par lettre recommandé avec AR dans le délai légal de 14 jours.
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
Mentions RGPD
-
-
-
- Vous vous apprêtez à créer un compte sur Gestion sports ou à accéder pour la première fois à celui-ci.
-
- Si vous créez un compte, les réponses aux questions identifiées par un astérisque sont obligatoires et nécessaires au traitement de votre
- demande de création de compte sur Gestion sports.
-
- Les informations personnelles collectées au moyen du formulaire qui suit sont enregistrées dans un fichier informatisé de données par la CIUP.
-
-
- Pour les partenaires, les salariés de la fondation CIUP, et le personnel travaillant à la CIUP mais non salarié de la fondation CIUP, le compte
- est créé directement par la fondation CIUP en accord avec ces derniers et sur la base des informations qui lui sont communiquées directement selon
- le cas par le partenaire ou par l’employeur concerné (nom, prénom, adresse e-mail, sexe, numéro de téléphone).
- A l’exception des partenaires, Vous pourrez ensuite compléter votre profil en y ajoutant notamment une photo.
-
-
- Le traitement est basé sur l’exécution d’un contrat avec la fondation CIUP.
-
- Vos données ne seront traitées et utilisées que dans la mesure où cela est nécessaire pour :
-
- - le traitement de votre demande de création de compte, la gestion de votre dossier, de vos abonnements, de vos réservations, à l’accès aux
- services proposés sur l’outil et à votre identification à l’entrée des cours de sport via un QR code personnel (usagers personnes physiques).
- - la gestion du contrat, de la facturation et des réservations (personnes morales partenaires de la CIUP)
-
- Vos informations personnelles sont conservées pour la durée des finalités pour lesquelles elles ont été collectées sauf si :
-
- • Vous exercez votre droit de suppression des données vous concernant, dans les conditions décrites ci-après ;
- • Une durée de conservation plus longue est autorisée ou imposée en vertu d’une obligation légale ou règlementaire.
-
-
-
-
-
-
-
Finalités
-
Durée de conservation
-
-
-
-
-
création de compte, la gestion de votre dossier, de vos abonnements,
- de vos réservations et votre identification à l’entrée
- des cours de sport (usagers personnes physiques)
-
Durée de l’abonnement + une année
-
-
-
gestion du contrat, de la facturation et des réservations (partenaires)
-
Durée de la relation contractuelle + une année
-
-
-
-
-
- Pendant la durée de conservation de vos données personnelles, nous nous engageons à mettre en œuvre les mesures nécessaires en vue d’assurer la
- confidentialité et la sécurité de celles-ci.
-
- L'accès à vos données personnelles est strictement limité à la fondation CIUP, à ses partenaires sportifs, ainsi qu’à ses sous-traitants
- (notamment l’éditeur de l’outil Gestion Sports).
-
- Ces derniers ne peuvent utiliser vos données qu’en conformité avec nos dispositions contractuelles et la législation applicable en matière
- de protection des données personnelles.
-
-
-
- Nous nous engageons ainsi et sauf obligation légale, à ne pas vendre, louer, céder ni donner accès à des tiers à vos données sans votre
- consentement préalable.
-
- L'accès à vos données personnelles est strictement limité à la fondation CIUP, à ses partenaires sportifs, ainsi qu’à ses sous-traitants
- (notamment l’éditeur de l’outil Gestion Sports).
-
- Conformément à la loi n° 78-17 du 6 janvier 1978 modifiée, relative à l'informatique, aux fichiers et aux libertés, vous disposez d'un droit d'accès,
- d'opposition, de rectification, de portabilité, et d’effacement des données qui vous concernent, ainsi que d’un droit de limitation du traitement
- de celles-ci.
-
- Pour exercer ce droit, vous pouvez adresser un message électronique à dpo@ciup.fr
-
-
-
- Vous pouvez également consulter notre politique de protection des données personnelles sur le site CIUP.FR.
-
- Pour toute information complémentaire ou réclamation, vous pouvez contacter la Commission Nationale de l’Informatique et des Libertés (www.cnil.fr).
- Avant tout accès aux courts, toute personne désirant jouer doivent obligatoirement figurer au tableau de réservation en ligne, en échange d’une clé
- (maison, voiture ou scooter). Pour les personnes non- abonnées, une clé personnelle devra être remise en échange de la clé du court de tennis.
-
- Le passe sanitaire de chaque joueur est contrôlé avant la remise des clés.Les groupements utilisateurs extérieurs sont durant toute leur présence
- (accès, séance, départ) sous la responsabilité et l’autorité de la personne désignée en début d’année auprès de la direction du service des sports.
-
- L'accès à une partie ou à la totalité des courts peut être interdit de façon ponctuelle (compétitions, travaux et maintenance, conditions atmosphériques
- défavorable..). Aucune indemnité compensatoire ne pourra être demandée.
-
- En cas d’empêchement, de non-attribution du terrain pour force majeure, la réservation en ligne ne donnera pas lieu à une contrepartie financière ou
- à un remboursement des frais (si l’annulation est faite 24 heures avant le créneau qui a été réservé par l’utilisateur).
-
- En cas de retard de plus de 15 minutes, la réservation est annulée sans contrepartie financière.
-
- Dans la mesure du possible, l'indisponibilité des courts lors de ces périodes sera affichée préalablement en ligne.
-
- Les utilisateurs de la dernière séance devront avoir évacué les courts de tennis et rendu les clés à l’heure de fin de créneau.
-
-
2. Réservation des courts
-
- Les réservations s'effectuent en ligne sur les courts attribués aux différents groupements utilisateurs à partir du lundi 08h00, pour la semaine à venir.
-
-
3. Tarifs
-
- Les tarifs sont consultables en ligne.
-
-
4. Temps de jeu
-
- Le temps de jeu est d'une durée d'une heure (de heure à heure).
- A la fin du temps de jeu, la clé du court sera remise au contrôleur-gardien en échange de la clé personnelle.
-
-
5. Comportement et tenue
-
- Une tenue adaptée à la pratique du tennis et un comportement correct sont de rigueur.
- L'accès aux courts est réservé aux seuls joueurs autorisés et aux officiels s'il y a lieu.
-
- Tout matériel ou véhicule (poussette, bicyclette...) est strictement interdit sur les courts de tennis.
- Aucun enseignement ou entraînement ne peut se dérouler sans autorisation préalable.
-
- En cas d’abus répétés, d’utilisation frauduleuse ou d’un accès illicite aux terrains en dehors des heures d’ouvertures,
- l’adhérent pourra être sanctionné sans aucune indemnité financière.
-
- Il s'agit d'une réservation classique où tu peux entrer tes partenaires et valider ta réservation.
-
-
Qu'est-ce qu'un Match Public ?
-
Tu cherches des partenaires ? Crée un match public.
- Ton créneau sera automatiquement réservé. C'est toi le boss de la partie.
-
Tous les autres Joueurs verront ton match et pourront y participer.
-
Si le match réunitJoueurs, le match est confirmé !
- Tout le monde aura un message de confirmation.
-
Si le match ne rassemble pas, le match sera annulé et le terrain sera libéré pour laisser la place aux autres.
- Les Joueurs seront évidemment informés.
-
Comment rejoindre un match ?
-
-
-
Clique sur "Rejoindre le match" ou retire toi d'un match en cliquant sur "J'abandonne"
-
-
Qu'est ce qu'un Match certifié ?
-
Lorsque le match est certifié, le club s'engage à ce que le niveau du joueur corresponde à son niveau réel.
- Le Mas
- à l'instant
- 
- 
- 
-
-