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()