padelclub_backend/tournaments/services/tournament_registration.py

from django.utils import timezone
from ..forms import TournamentRegistrationForm, AddPlayerForm
from ..validators import TournamentRegistrationValidator
from ..repositories import TournamentRegistrationRepository
from .email_service import TournamentEmailService

class TournamentRegistrationService:
    def __init__(self, request, tournament):
        self.request = request
        self.tournament = tournament
        self.context = {}
        self.repository = TournamentRegistrationRepository()
        self.validator = TournamentRegistrationValidator()
        self.email_service = TournamentEmailService()

    def initialize_context(self):
        self.context = {
            'tournament': self.tournament,
            'registration_successful': False,
            'team_form': None,
            'add_player_form': None,
            'current_players': self.request.session.get('team_registration', []),
            'user_without_licence': self.request.session.get('user_without_licence', False)
        }
        return self.context

    def handle_post_request(self):
        self.context['team_form'] = TournamentRegistrationForm(self.request.POST)
        self.context['add_player_form'] = AddPlayerForm(self.request.POST)

        if 'add_player' in self.request.POST:
            self.handle_add_player()
        elif 'register_team' in self.request.POST:
            self.handle_team_registration()

    def handle_add_player(self):
        if not self.context['add_player_form'].is_valid():
            return

        player_data = self.context['add_player_form'].cleaned_data
        if not self.validator.validate_player_license(self.request, self.tournament, player_data):
            return

        self.add_player_to_session(player_data)
        self.context['add_player_form'] = AddPlayerForm()

    def handle_team_registration(self):
        if not self.context['team_form'].is_valid():
            return

        team_registration = self.repository.create_team_registration(
            self.tournament,
            timezone.now().replace(microsecond=0)
        )

        self.repository.create_player_registrations(
            self.request,
            team_registration,
            self.request.session['team_registration'],
            self.context['team_form'].cleaned_data
        )

        self.email_service.send_registration_confirmation(
            self.request,
            self.tournament,
            team_registration
        )

        self.clear_session_data()
        self.context['registration_successful'] = True

    def handle_get_request(self):
        self.context['add_player_form'] = AddPlayerForm()
        self.context['team_form'] = self.initialize_team_form()
        self.initialize_session_data()

    def add_player_to_session(self, player_data):
        if not self.request.session.get('team_registration'):
            self.request.session['team_registration'] = []

        self.request.session['team_registration'].append(player_data)
        self.request.session.modified = True

    def clear_session_data(self):
        self.request.session['team_registration'] = []
        self.request.session.modified = True

    def initialize_team_form(self):
        initial_data = {}
        if self.request.user.is_authenticated:
            initial_data = {
                'email': self.request.user.email,
                'phone': self.request.user.phone,
            }
        return TournamentRegistrationForm(initial=initial_data)

    def initialize_session_data(self):
        print("initialize_session_data")
        self.request.session['team_registration'] = []
        if self.request.user.is_authenticated:
            self._add_authenticated_user_to_session()

    def _add_authenticated_user_to_session(self):
        if not self.request.user.licence_id:
            self._handle_user_without_license()
            return

        player_data = self._get_authenticated_user_data()
        if player_data:
            self.context['current_players'] = self.request.session.get('team_registration', [])
            self.request.session['team_registration'].insert(0, player_data)
            self.request.session.modified = True

    def _handle_user_without_license(self):
        player_data = {
            'first_name': self.request.user.first_name,
            'last_name': self.request.user.last_name.upper(),
        }
        self.context['add_player_form'] = AddPlayerForm(initial=player_data)
        self.request.session['user_without_licence'] = True
        self.request.session.modified = True

    def _get_authenticated_user_data(self):
        from ..utils.player_search import get_player_name_from_csv
        from ..validators import LicenseValidator
        user = self.request.user
        validator = LicenseValidator(user.licence_id)

        player_data = {
            'first_name': user.first_name,
            'last_name': user.last_name.upper(),
            'email': user.email,
            'phone': user.phone,
            'licence_id': validator.computed_licence_id
        }

        data, found = get_player_name_from_csv(self.tournament.federal_category, user.licence_id)
        if found and data:
            player_data.update({
                'rank': data['rank'],
                'points': data.get('points'),
                'assimilation': data.get('assimilation'),
                'tournament_count': data.get('tournament_count'),
                'ligue_name': data.get('ligue_name'),
                'club_name': data.get('club_name'),
                'birth_year': data.get('birth_year')
            })

        return player_data