Sekretny Mikołaj w Django

secret_santa/
├── models.py          # Modele: Event i Participant
├── views.py           # Logika widoków i obsługa formularza
├── forms.py           # Formularze do wprowadzania uczestników
├── sms_service.py     # Integracja z API SMS
├── urls.py            # Routing
└── templates/         # Szablony HTML
    ├── index.html     # Formularz z listą uczestników
    └── success.html   # Strona potwierdzenia

class SecretSantaEvent(models.Model):
    """Model reprezentujący wydarzenie Secret Santa"""
    created_at = models.DateTimeField(default=timezone.now)
    draw_completed = models.BooleanField(default=False)
    draw_date = models.DateTimeField(null=True, blank=True)

    def perform_draw(self):
        """
        Wykonuje losowanie zapewniając, że nikt nie wylosuje siebie.

        Używa algorytmu retry shuffle (derangement):
        - Tasuje odbiorców losowo
        - Sprawdza czy nikt nie wylosował siebie
        - Jeśli tak, powtarza z nowym tasowaniem
        - Powtarza aż do znalezienia poprawnego przypisania
        """
        participants = list(self.participants.all())
        if len(participants) < 3:
            raise ValueError("Wymagane minimum 3 uczestników")

        givers = participants.copy()
        receivers = participants.copy()

        # Retry shuffle until we find valid derangement
        max_attempts = 1000
        for attempt in range(max_attempts):
            random.shuffle(receivers)

            # Check if valid (no one gets themselves)
            if all(givers[i] != receivers[i] for i in range(len(givers))):
                # Valid assignment found!
                break
        else:
            raise ValueError("Nie udało się znaleźć poprawnego przypisania")

        # Przypisanie odbiorców do darczyńców
        for giver, receiver in zip(givers, receivers):
            giver.assigned_to = receiver
            giver.save()

        self.draw_completed = True
        self.draw_date = timezone.now()
        self.save()

class Participant(models.Model):
    """Model reprezentujący uczestnika Secret Santa"""
    event = models.ForeignKey(SecretSantaEvent, on_delete=models.CASCADE,
                             related_name='participants')
    name = models.CharField(max_length=100)
    phone_number = models.CharField(max_length=20,
                                   help_text="Numer z kodem kraju, np. +48123456789")
    assigned_to = models.ForeignKey('self', on_delete=models.SET_NULL,
                                    null=True, blank=True, related_name='secret_santa')
    sms_sent = models.BooleanField(default=False)
    sms_sent_at = models.DateTimeField(null=True, blank=True)

def perform_draw(self):
    participants = list(self.participants.all())
    givers = participants.copy()
    receivers = participants.copy()

    # Retry shuffle until we find valid derangement
    max_attempts = 1000
    for attempt in range(max_attempts):
        random.shuffle(receivers)

        # Check if valid (no one gets themselves)
        if all(givers[i] != receivers[i] for i in range(len(givers))):
            # Valid assignment found!
            break
    else:
        raise ValueError("Could not find valid assignment")

    # Assign receivers to givers
    for giver, receiver in zip(givers, receivers):
        giver.assigned_to = receiver
        giver.save()

class SMSService:
    """Abstrakcyjna usługa SMS wspierająca różnych providerów"""

    @staticmethod
    def send_sms(to_number, message):
        provider = getattr(settings, 'SMS_PROVIDER', 'console')

        if provider == 'twilio':
            return SMSService._send_via_twilio(to_number, message)
        elif provider == 'smsplanet':
            return SMSService._send_via_smsplanet(to_number, message)
        elif provider == 'console':
            return SMSService._send_via_console(to_number, message)

@staticmethod
def _send_via_smsplanet(to_number, message):
    """Wysyłka SMS przez SMSPLANET API"""
    api_token = getattr(settings, 'SMSPLANET_API_TOKEN', None)
    sender_field = getattr(settings, 'SMSPLANET_SENDER_FIELD', 'INFO')

    if not api_token:
        logger.error("Token API SMSPLANET nie jest skonfigurowany")
        return False

    # Normalizacja numeru (usunięcie +)
    phone = to_number.replace('+', '').replace(' ', '')

    # Przygotowanie requestu
    url = 'https://api2.smsplanet.pl/sms'
    headers = {
        'Authorization': f'Bearer {api_token}',
        'Content-Type': 'application/x-www-form-urlencoded'
    }

    data = {
        'from': sender_field,
        'to': phone,
        'msg': message
    }

    # Wysłanie
    response = requests.post(url, headers=headers, data=data, timeout=10)

    if response.status_code == 200:
        response_data = response.json()
        if 'messageId' in response_data:
            logger.info(f"SMS wysłany przez SMSPLANET do {to_number}")
            return True

    return False

def send_secret_santa_sms(participant):
    """Wysyła SMS z przypisaniem Secret Santa"""
    provider = getattr(settings, 'SMS_PROVIDER', 'console')

    # SMSPLANET nie obsługuje emoji - wersja tekstowa
    if provider == 'smsplanet':
        message = (
            f"Cześć {participant.name}!\n\n"
            f"W tegorocznym Secret Santa wylosowałeś/aś: {participant.assigned_to.name}\n\n"
            f"To jest tajna informacja - nikomu nie mów!\n\n"
            f"Wesołych Świąt!"
        )
    else:
        # Twilio i Console obsługują emoji
        message = (
            f"Cześć {participant.name}! 🎅\n\n"
            f"W tegorocznym Secret Santa wylosowałeś/aś: {participant.assigned_to.name}\n\n"
            f"To jest tajna informacja - nikomu nie mów! 🤫\n\n"
            f"Wesołych Świąt! 🎄"
        )

    return SMSService.send_sms(participant.phone_number, message)

class ParticipantForm(forms.Form):
    """Formularz dla pojedynczego uczestnika"""
    name = forms.CharField(max_length=100)
    phone_number = forms.CharField(max_length=20)

    def clean_phone_number(self):
        phone = self.cleaned_data['phone_number']
        # Walidacja - musi zaczynać się od + i zawierać tylko cyfry
        if not phone.startswith('+'):
            raise forms.ValidationError('Numer telefonu musi zaczynać się od + i kodu kraju')
        if not phone[1:].replace(' ', '').isdigit():
            raise forms.ValidationError('Numer telefonu może zawierać tylko cyfry po znaku +')
        return phone

# FormSet pozwalający na co najmniej 3 uczestników
ParticipantFormSet = formset_factory(
    ParticipantForm,
    extra=3,
    min_num=3,
    validate_min=True
)

def secret_santa_view(request):
    if request.method == 'POST':
        formset = ParticipantFormSet(request.POST)

        if formset.is_valid():
            try:
                with transaction.atomic():
                    # Utwórz wydarzenie
                    event = SecretSantaEvent.objects.create()

                    # Dodaj uczestników
                    for form in formset:
                        if form.cleaned_data:
                            Participant.objects.create(
                                event=event,
                                name=form.cleaned_data['name'],
                                phone_number=form.cleaned_data['phone_number']
                            )

                    # Wykonaj losowanie
                    event.perform_draw()

                    # Wyślij SMS-y
                    success_count = 0
                    for participant in event.participants.all():
                        if send_secret_santa_sms(participant):
                            success_count += 1

                    messages.success(request,
                        f'🎅 Losowanie zakończone! Wysłano {success_count} SMS-ów.')
                    return redirect('secret_santa:success')

            except Exception as e:
                logger.error(f"Błąd podczas losowania: {e}")
                messages.error(request, 'Wystąpił błąd. Spróbuj ponownie.')
    else:
        formset = ParticipantFormSet()

    return render(request, 'secret_santa/index.html', {'formset': formset})