You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
449 lines
18 KiB
449 lines
18 KiB
from django.utils import timezone
|
|
import uuid
|
|
import datetime
|
|
from ..models import PlayerRegistration, TeamRegistration, Tournament
|
|
from ..utils.licence_validator import LicenseValidator
|
|
from ..utils.player_search import get_player_name_from_csv
|
|
|
|
class RegistrationCartManager:
|
|
"""
|
|
Manages the registration cart for tournament registrations.
|
|
Handles session-based cart operations, player additions/removals,
|
|
and checkout processes.
|
|
"""
|
|
|
|
CART_EXPIRY_MINUTES = 30
|
|
|
|
def __init__(self, request):
|
|
self.request = request
|
|
self.session = request.session
|
|
|
|
def get_or_create_cart_id(self):
|
|
"""Get or create a registration cart ID in the session"""
|
|
if 'registration_cart_id' not in self.session:
|
|
self.session['registration_cart_id'] = str(uuid.uuid4()) # Ensure it's a string
|
|
self.session.modified = True
|
|
return self.session['registration_cart_id']
|
|
|
|
def get_cart_expiry(self):
|
|
"""Get the cart expiry time from the session"""
|
|
if 'registration_cart_expiry' not in self.session:
|
|
# Set default expiry to 30 minutes from now
|
|
expiry = timezone.now() + datetime.timedelta(minutes=self.CART_EXPIRY_MINUTES)
|
|
self.session['registration_cart_expiry'] = expiry.isoformat()
|
|
self.session.modified = True
|
|
return self.session['registration_cart_expiry']
|
|
|
|
def is_cart_expired(self):
|
|
"""Check if the registration cart is expired"""
|
|
if 'registration_cart_expiry' not in self.session:
|
|
return False
|
|
|
|
expiry_str = self.session['registration_cart_expiry']
|
|
try:
|
|
expiry = datetime.datetime.fromisoformat(expiry_str)
|
|
return timezone.now() > expiry
|
|
except (ValueError, TypeError):
|
|
return True
|
|
|
|
def reset_cart_expiry(self):
|
|
"""Reset the cart expiry time"""
|
|
expiry = timezone.now() + datetime.timedelta(minutes=self.CART_EXPIRY_MINUTES)
|
|
self.session['registration_cart_expiry'] = expiry.isoformat()
|
|
self.session.modified = True
|
|
|
|
def get_tournament_id(self):
|
|
"""Get the tournament ID associated with the current cart"""
|
|
return self.session.get('registration_tournament_id')
|
|
|
|
def initialize_cart(self, tournament_id):
|
|
"""Initialize a new registration cart for a tournament"""
|
|
# Clear any existing cart
|
|
self.clear_cart()
|
|
|
|
try:
|
|
tournament = Tournament.objects.get(id=tournament_id)
|
|
except Tournament.DoesNotExist:
|
|
return False, "Tournoi introuvable."
|
|
|
|
# Update tournament reserved spots
|
|
tournament.reserved_spots = max(0, tournament.reserved_spots - 1)
|
|
waiting_list_position = tournament.get_waiting_list_position()
|
|
|
|
if waiting_list_position >= 0:
|
|
tournament.reserved_spots = 0
|
|
else:
|
|
tournament.reserved_spots += 1
|
|
|
|
tournament.save()
|
|
|
|
# Set up the new cart
|
|
self.session['registration_cart_id'] = str(uuid.uuid4()) # Ensure it's a string
|
|
self.session['waiting_list_position'] = waiting_list_position
|
|
self.session['registration_tournament_id'] = str(tournament_id) # Ensure it's a string
|
|
self.session['registration_cart_players'] = []
|
|
self.reset_cart_expiry()
|
|
self.session.modified = True
|
|
|
|
return True, "Cart initialized successfully"
|
|
|
|
def get_cart_data(self):
|
|
"""Get the data for the current registration cart"""
|
|
# Ensure cart players array exists
|
|
if 'registration_cart_players' not in self.session:
|
|
self.session['registration_cart_players'] = []
|
|
self.session.modified = True
|
|
|
|
# Ensure tournament ID exists
|
|
if 'registration_tournament_id' not in self.session:
|
|
# If no tournament ID but we have players, this is an inconsistency
|
|
if self.session.get('registration_cart_players'):
|
|
print("WARNING: Found players but no tournament ID - clearing players")
|
|
self.session['registration_cart_players'] = []
|
|
self.session.modified = True
|
|
|
|
# Get user phone if authenticated
|
|
user_phone = ''
|
|
if hasattr(self.request.user, 'phone'):
|
|
user_phone = self.request.user.phone
|
|
|
|
cart_data = {
|
|
'cart_id': self.get_or_create_cart_id(),
|
|
'tournament_id': self.session.get('registration_tournament_id'),
|
|
'waiting_list_position': self.session.get('waiting_list_position'),
|
|
'players': self.session.get('registration_cart_players', []),
|
|
'expiry': self.get_cart_expiry(),
|
|
'mobile_number': self.session.get('registration_mobile_number', user_phone)
|
|
}
|
|
|
|
# Debug: print the cart content
|
|
print(f"Cart data - Tournament ID: {cart_data['tournament_id']}")
|
|
print(f"Cart data - Players count: {len(cart_data['players'])}")
|
|
|
|
return cart_data
|
|
|
|
def add_player(self, player_data):
|
|
"""Add a player to the registration cart"""
|
|
if self.is_cart_expired():
|
|
return False, "Votre session d'inscription a expiré, veuillez réessayer."
|
|
|
|
# Get cart data
|
|
tournament_id = self.session.get('registration_tournament_id')
|
|
if not tournament_id:
|
|
return False, "Pas d'inscription active."
|
|
|
|
# Get tournament
|
|
try:
|
|
tournament = Tournament.objects.get(id=tournament_id)
|
|
except Tournament.DoesNotExist:
|
|
return False, "Tournoi introuvable."
|
|
|
|
# Get existing players directly from session
|
|
players = self.session.get('registration_cart_players', [])
|
|
|
|
# Check if we've reached the team limit
|
|
if len(players) >= 2: # Assuming teams of 2 for padel
|
|
return False, "Nombre maximum de joueurs déjà ajouté."
|
|
|
|
# Process player data
|
|
licence_id = player_data.get('licence_id', '').upper() if player_data.get('licence_id') else None
|
|
first_name = player_data.get('first_name', '')
|
|
last_name = player_data.get('last_name', '').upper() if player_data.get('last_name') else ''
|
|
|
|
# Handle license validation logic
|
|
result = self._process_player_license(
|
|
tournament, licence_id, first_name, last_name, players, len(players) == 0
|
|
)
|
|
if not result[0]:
|
|
return result # Return the error
|
|
|
|
# If we got here, license validation passed
|
|
if licence_id:
|
|
# Get federation data
|
|
fed_data, found = get_player_name_from_csv(tournament.federal_category, licence_id)
|
|
if found and fed_data:
|
|
# Use federation data (including check for eligibility)
|
|
player_register_check = tournament.player_register_check(licence_id)
|
|
if player_register_check:
|
|
return False, ", ".join(player_register_check)
|
|
|
|
# Update player data from federation data
|
|
player_data.update({
|
|
'first_name': fed_data['first_name'],
|
|
'last_name': fed_data['last_name'],
|
|
'rank': fed_data['rank'],
|
|
'is_woman': fed_data['is_woman'],
|
|
'points': fed_data.get('points'),
|
|
'assimilation': fed_data.get('assimilation'),
|
|
'tournament_count': fed_data.get('tournament_count'),
|
|
'ligue_name': fed_data.get('ligue_name'),
|
|
'club_name': fed_data.get('club_name'),
|
|
'birth_year': fed_data.get('birth_year'),
|
|
'found_in_french_federation': True,
|
|
})
|
|
elif tournament.license_is_required:
|
|
# License required but not found in federation data
|
|
return False, "La licence fournit n'a pas été trouvée dans la base FFT. Contactez le juge arbitre si cette licence est valide."
|
|
elif not first_name or not last_name:
|
|
# License not required or not found, but name is needed
|
|
return False, "Le prénom et le nom sont obligatoires pour les joueurs sans licence."
|
|
elif not tournament.license_is_required:
|
|
# License not required, check if name is provided
|
|
if not first_name or not last_name:
|
|
return False, "Le prénom et le nom sont obligatoires pour les joueurs sans licence."
|
|
|
|
# Set default rank for players without a license
|
|
if player_data.get('rank') is None:
|
|
default_data, _ = get_player_name_from_csv(tournament.federal_category, None)
|
|
if default_data:
|
|
player_data['rank'] = default_data.get('rank')
|
|
player_data['is_woman'] = default_data.get('is_woman', False)
|
|
else:
|
|
# License is required but not provided
|
|
return False, "Le numéro de licence est obligatoire."
|
|
|
|
# Add player to cart
|
|
players.append(player_data)
|
|
self.session['registration_cart_players'] = players
|
|
self.reset_cart_expiry()
|
|
self.session.modified = True
|
|
|
|
return True, "Joueur ajouté avec succès."
|
|
|
|
def _process_player_license(self, tournament, licence_id, first_name, last_name, players, is_first_player):
|
|
"""
|
|
Process and validate player license
|
|
Returns (True, None) if valid, (False, error_message) if invalid
|
|
"""
|
|
# Handle case where license is required
|
|
if tournament.license_is_required:
|
|
# If license is required but not provided
|
|
if not licence_id:
|
|
# First player (authentication check) or partner
|
|
user_message = "Le numéro de licence est obligatoire." if is_first_player else "Le numéro de licence de votre partenaire est obligatoire."
|
|
return False, user_message
|
|
|
|
# Validate the license format
|
|
validator = LicenseValidator(licence_id)
|
|
if not validator.validate_license():
|
|
return False, "Le numéro de licence est invalide, la lettre ne correspond pas."
|
|
|
|
# Check if player is already registered in tournament
|
|
stripped_license = validator.stripped_license
|
|
if self._is_player_already_registered(stripped_license, tournament):
|
|
return False, "Un joueur avec ce numéro de licence est déjà inscrit dans une équipe."
|
|
|
|
# Check if this is the authenticated user trying to register as first player
|
|
if self.request.user.is_authenticated and is_first_player and self.request.user.licence_id is None:
|
|
# Try to update the user's license ID in the database
|
|
try:
|
|
self.request.user.licence_id = validator.computed_licence_id
|
|
self.request.user.save()
|
|
self.request.user.refresh_from_db()
|
|
except:
|
|
return False, "Erreur lors de la mise à jour de votre licence: cette licence est déjà utilisée par un autre joueur."
|
|
|
|
# Check for duplicate licenses in cart
|
|
existing_licenses = [p.get('licence_id') for p in players if p.get('licence_id')]
|
|
if licence_id and licence_id in existing_licenses:
|
|
return False, "Ce joueur est déjà dans l'équipe."
|
|
|
|
return True, None
|
|
|
|
def remove_player(self):
|
|
"""Remove the last player from the cart"""
|
|
if self.is_cart_expired():
|
|
return False, "Votre session d'inscription a expiré, veuillez réessayer."
|
|
|
|
players = self.session.get('registration_cart_players', [])
|
|
if not players:
|
|
return False, "Pas de joueur à supprimer."
|
|
|
|
# Remove last player
|
|
players.pop()
|
|
self.session['registration_cart_players'] = players
|
|
self.reset_cart_expiry()
|
|
self.session.modified = True
|
|
|
|
return True, "Joueur retiré."
|
|
|
|
def update_contact_info(self, mobile_number=None):
|
|
"""Update contact info for the cart"""
|
|
if self.is_cart_expired():
|
|
return False, "Votre session d'inscription a expiré, veuillez réessayer."
|
|
|
|
if mobile_number is not None:
|
|
self.session['registration_mobile_number'] = mobile_number
|
|
|
|
self.reset_cart_expiry()
|
|
self.session.modified = True
|
|
|
|
return True, "Informations de contact mises à jour."
|
|
|
|
def checkout(self):
|
|
"""Convert cart to an actual tournament registration"""
|
|
if self.is_cart_expired():
|
|
return False, "Votre session d'inscription a expiré, veuillez réessayer."
|
|
|
|
# Get cart data
|
|
cart_data = self.get_cart_data()
|
|
tournament_id = cart_data.get('tournament_id')
|
|
players = cart_data.get('players')
|
|
mobile_number = cart_data.get('mobile_number')
|
|
|
|
# Validate cart data
|
|
if not tournament_id:
|
|
return False, "Aucun tournoi sélectionné."
|
|
|
|
if not players:
|
|
return False, "Aucun joueur dans l'inscription."
|
|
|
|
# Get tournament
|
|
try:
|
|
tournament = Tournament.objects.get(id=tournament_id)
|
|
except Tournament.DoesNotExist:
|
|
return False, "Tournoi introuvable."
|
|
|
|
# Check minimum players
|
|
if len(players) < tournament.minimum_player_per_team:
|
|
return False, f"Vous avez besoin d'au moins {tournament.minimum_player_per_team} joueurs pour vous inscrire."
|
|
|
|
# Create team registration
|
|
team_registration = TeamRegistration.objects.create(
|
|
tournament=tournament,
|
|
registration_date=timezone.now(),
|
|
walk_out=False
|
|
)
|
|
|
|
# Create player registrations
|
|
for idx, player_data in enumerate(players):
|
|
PlayerRegistration.objects.create(
|
|
team_registration=team_registration,
|
|
first_name=player_data.get('first_name', ''),
|
|
last_name=player_data.get('last_name', '').upper(),
|
|
licence_id=player_data.get('licence_id'),
|
|
rank=player_data.get('rank'),
|
|
points=player_data.get('points'),
|
|
club_name=player_data.get('club_name'),
|
|
ligue_name=player_data.get('ligue_name'),
|
|
email=player_data.get('email'),
|
|
phone_number=player_data.get('phone'),
|
|
assimilation=player_data.get('assimilation'),
|
|
tournament_played=player_data.get('tournament_count'),
|
|
birthdate=str(player_data.get('birth_year', '')),
|
|
captain=(idx == 0), # First player is captain
|
|
registered_online=True,
|
|
registration_status='CONFIRMED' if self.session['waiting_list_position'] < 0 else 'WAITING'
|
|
)
|
|
|
|
# Update user phone if provided
|
|
if self.request.user.is_authenticated and mobile_number:
|
|
self.request.user.phone = mobile_number
|
|
self.request.user.save(update_fields=['phone'])
|
|
|
|
# Clear the cart
|
|
self.clear_cart()
|
|
tournament.reserved_spots = max(0, tournament.reserved_spots - 1)
|
|
tournament.save()
|
|
|
|
return True, team_registration
|
|
|
|
def clear_cart(self):
|
|
"""Clear the registration cart"""
|
|
keys_to_clear = [
|
|
'registration_cart_id',
|
|
'team_registration_id',
|
|
'registration_tournament_id',
|
|
'registration_cart_players',
|
|
'registration_cart_expiry',
|
|
'registration_mobile_number'
|
|
]
|
|
|
|
for key in keys_to_clear:
|
|
if key in self.session:
|
|
del self.session[key]
|
|
|
|
self.session.modified = True
|
|
|
|
def _is_player_already_registered(self, stripped_license, tournament):
|
|
"""Check if a player is already registered in the tournament"""
|
|
return PlayerRegistration.objects.filter(
|
|
team_registration__tournament=tournament,
|
|
licence_id__icontains=stripped_license,
|
|
team_registration__walk_out=False
|
|
).exists()
|
|
|
|
def add_authenticated_user(self):
|
|
"""
|
|
Adds the authenticated user to the cart if they have a valid license.
|
|
Returns True if added, False otherwise.
|
|
"""
|
|
if not self.request.user.is_authenticated or not self.request.user.licence_id:
|
|
return False
|
|
|
|
# Create player data for the authenticated user
|
|
player_data = {
|
|
'first_name': self.request.user.first_name,
|
|
'last_name': self.request.user.last_name,
|
|
'licence_id': self.request.user.licence_id,
|
|
'email': self.request.user.email,
|
|
'phone': self.request.user.phone
|
|
}
|
|
|
|
# Add the user to the cart
|
|
success, _ = self.add_player(player_data)
|
|
return success
|
|
|
|
|
|
# For backward compatibility with existing code that uses the function-based approach
|
|
def get_or_create_registration_cart_id(request):
|
|
cart_manager = RegistrationCartManager(request)
|
|
return cart_manager.get_or_create_cart_id()
|
|
|
|
def get_cart_expiry(request):
|
|
cart_manager = RegistrationCartManager(request)
|
|
return cart_manager.get_cart_expiry()
|
|
|
|
def is_cart_expired(request):
|
|
cart_manager = RegistrationCartManager(request)
|
|
return cart_manager.is_cart_expired()
|
|
|
|
def reset_cart_expiry(request):
|
|
cart_manager = RegistrationCartManager(request)
|
|
cart_manager.reset_cart_expiry()
|
|
|
|
def get_tournament_from_cart(request):
|
|
cart_manager = RegistrationCartManager(request)
|
|
return cart_manager.get_tournament_id()
|
|
|
|
def initialize_registration_cart(request, tournament_id):
|
|
cart_manager = RegistrationCartManager(request)
|
|
return cart_manager.initialize_cart(tournament_id)
|
|
|
|
def get_registration_cart_data(request):
|
|
cart_manager = RegistrationCartManager(request)
|
|
return cart_manager.get_cart_data()
|
|
|
|
def add_player_to_cart(request, player_data):
|
|
cart_manager = RegistrationCartManager(request)
|
|
return cart_manager.add_player(player_data)
|
|
|
|
def remove_player_from_cart(request):
|
|
cart_manager = RegistrationCartManager(request)
|
|
return cart_manager.remove_player()
|
|
|
|
def update_cart_contact_info(request, mobile_number=None):
|
|
cart_manager = RegistrationCartManager(request)
|
|
return cart_manager.update_contact_info(mobile_number)
|
|
|
|
def checkout_registration_cart(request):
|
|
cart_manager = RegistrationCartManager(request)
|
|
return cart_manager.checkout()
|
|
|
|
def clear_registration_cart(request):
|
|
cart_manager = RegistrationCartManager(request)
|
|
cart_manager.clear_cart()
|
|
|
|
def add_authenticated_user_to_cart(request):
|
|
cart_manager = RegistrationCartManager(request)
|
|
return cart_manager.add_authenticated_user()
|
|
|