Add participant management without user authentication

Fixes #8

Add support for participants without user authentication and manage their participation in tournaments.

* Add `Participant` class with a nullable foreign reference to `auth.User` in `tournaments/tournaments/models.py`.
* Modify `Participation` class to reference `Participant` instead of `auth.User` in `tournaments/tournaments/models.py`.
* Update `required_confirmations_count` method to count only participants with non-null `auth.User` in `tournaments/tournaments/models.py`.
* Add `ManageParticipantsView` to manage participants without user authentication in `tournaments/frontend/views.py`.
* Modify `JoinTournamentView` and `WithdrawTournamentView` to support participants without user authentication in `tournaments/frontend/views.py`.
* Add migration to create `Participant` model and update `Participation` model in `tournaments/tournaments/migrations/0003_add_participant.py`.
* Add HTML template for managing participants without user authentication in `tournaments/frontend/templates/frontend/manage-participants.html`.
* Add tests to verify the new functionality for participants without user authentication in `tournaments/frontend/tests.py`.

---

For more details, open the [Copilot Workspace session](https://copilot-workspace.githubnext.com/kosmotive/tournaments/issues/8?shareId=XXXX-XXXX-XXXX-XXXX).

Author: kostrykin

tournaments/frontend/templates/frontend/manage-participants.html

@@ -0,0 +1,18 @@
+{% extends "frontend/base.html" %}
+
+{% block title %}Manage Participants{% endblock %}
+
+{% block header %}
+<h1>Manage Participants</h1>
+{% endblock %}
+
+{% block content %}
+<form method="post" action="{% url 'manage-participants' pk=tournament.id %}">
+    {% csrf_token %}
+    <div class="form-group">
+        <label for="participant_names">Participant Names (one per line)</label>
+        <textarea class="form-control" id="participant_names" name="participant_names" rows="10" required></textarea>
+    </div>
+    <button type="submit" class="btn btn-primary">Save Participants</button>
+</form>
+{% endblock %}

tournaments/frontend/tests.py

@@ -329,7 +329,7 @@ def add_participators(tournament, number = 10):
         tournament.save()
     users = [models.User.objects.get_or_create(username = f'user{idx}')[0] for idx in range(number)]
     for user in users:
-        models.Participation.objects.create(tournament = tournament, user = user, slot_id = models.Participation.next_slot_id(tournament))
+        models.Participation.objects.create(tournament = tournament, participant = models.Participant.objects.create(user = user, name = user.username), slot_id = models.Participation.next_slot_id(tournament))
     return users
 
 
@@ -500,7 +500,7 @@ def setUp(self):
 
         for tournament in models.Participation.objects.all():
             for user in models.User.objects.all():
-                models.Participation.objects.create(tournament = tournament, user = user, slot_id = models.Participation.next_slot_id(tournament))
+                models.Participation.objects.create(tournament = tournament, participant = models.Participant.objects.create(user = user, name = user.username), slot_id = models.Participation.next_slot_id(tournament))
 
     def test_unauthenticated(self):
         self.client.logout()
@@ -790,3 +790,37 @@ def test_post(self):
         self.assertContains(response, 'Your confirmation has been saved.')
         self.assertContains(response, 'Confirmations: 1 / 6')
         self.assertContains(response, 'You have confirmed.')
+
+
+class ManageParticipantsViewTests(TestCase):
+
+    def setUp(self):
+        self.user1 = models.User.objects.create(username = 'test1')
+        self.user2 = models.User.objects.create(username = 'test2')
+        self.client.force_login(self.user1)
+
+        self.tournament1 = models.Tournament.load(definition = test_tournament1_yml, name = 'Test1', creator = self.user1, published = True)
+        self.tournament2 = models.Tournament.load(definition = test_tournament1_yml, name = 'Test2', creator = self.user2, published = True)
+
+    def test_get(self):
+        response = self.client.get(reverse('manage-participants', kwargs = dict(pk = self.tournament1.id)))
+        self.assertEqual(response.status_code, 200)
+        self.assertContains(response, 'Manage Participants')
+        self.assertContains(response, 'Participant Names (one per line)')
+        self.assertContains(response, 'Save Participants')
+
+    def test_post(self):
+        participant_names = "Participant1\nParticipant2\nParticipant3"
+        response = self.client.post(reverse('manage-participants', kwargs = dict(pk = self.tournament1.id)),
+                                    dict(participant_names = participant_names), follow = True)
+        self.assertEqual(response.status_code, 200)
+        self.assertContains(response, 'Participants have been updated.')
+        self.assertTrue(models.Participant.objects.filter(name = 'Participant1').exists())
+        self.assertTrue(models.Participant.objects.filter(name = 'Participant2').exists())
+        self.assertTrue(models.Participant.objects.filter(name = 'Participant3').exists())
+        self.assertTrue(models.Participation.objects.filter(tournament = self.tournament1, participant__name = 'Participant1').exists())
+        self.assertTrue(models.Participation.objects.filter(tournament = self.tournament1, participant__name = 'Participant2').exists())
+        self.assertTrue(models.Participation.objects.filter(tournament = self.tournament1, participant__name = 'Participant3').exists())
+        self.assertFalse(models.Participant.objects.filter(name = 'Participant1', participations__isnull = True).exists())
+        self.assertFalse(models.Participant.objects.filter(name = 'Participant2', participations__isnull = True).exists())
+        self.assertFalse(models.Participant.objects.filter(name = 'Participant3', participations__isnull = True).exists())

tournaments/frontend/views.py

@@ -226,10 +226,11 @@ def get(self, request, *args, **kwargs):
             return HttpResponse(status = 412)
 
         # Create the participation only if it does not already exist.
-        if not self.object.participations.filter(user = request.user).exists():
+        if not self.object.participations.filter(participant__user = request.user).exists():
+            participant, created = models.Participant.objects.get_or_create(user = request.user, defaults = {'name': request.user.username})
             models.Participation.objects.create(
                 tournament = self.object,
-                user = self.request.user,
+                participant = participant,
                 slot_id = models.Participation.next_slot_id(self.object))
 
         request.session['alert'] = dict(status = 'success', text = 'You have joined the tournament.')
@@ -248,13 +249,43 @@ def get(self, request, *args, **kwargs):
             return HttpResponse(status = 412)
 
         # Delete the participation only if it exists.
-        if self.object.participations.filter(user = request.user).exists():
-            models.Participation.objects.filter(user = request.user).delete()
+        if self.object.participations.filter(participant__user = request.user).exists():
+            self.object.participations.filter(participant__user = request.user).delete()
 
         request.session['alert'] = dict(status = 'success', text = 'You have withdrawn from the tournament.')
         return redirect('update-tournament', pk = self.object.id)
 
 
+class ManageParticipantsView(IsCreatorMixin, SingleObjectMixin, VersionInfoMixin, AlertMixin, View):
+
+    model = models.Tournament
+    template_name = 'frontend/manage-participants.html'
+
+    def get(self, request, *args, **kwargs):
+        self.object = self.get_object()
+        context = self.get_context_data(**kwargs)
+        context['participants'] = self.object.participations.all()
+        return render(request, self.template_name, context)
+
+    def post(self, request, *args, **kwargs):
+        self.object = self.get_object()
+        participant_names = request.POST.get('participant_names')
+        if participant_names:
+            participant_names_list = participant_names.splitlines()
+            for participant_name in participant_names_list:
+                participant, created = models.Participant.objects.get_or_create(name = participant_name)
+                if not self.object.participations.filter(participant = participant).exists():
+                    models.Participation.objects.create(
+                        tournament = self.object,
+                        participant = participant,
+                        slot_id = models.Participation.next_slot_id(self.object)
+                    )
+            # Automatically delete participants that are not part of any tournament
+            models.Participant.objects.filter(participations__isnull = True, user__isnull = True).delete()
+            request.session['alert'] = dict(status = 'success', text = f'Participants have been updated.')
+        return redirect('manage-participants', pk = self.object.id)
+
+
 class TournamentProgressView(SingleObjectMixin, VersionInfoMixin, AlertMixin, View):
 
     model = models.Tournament
@@ -299,7 +330,7 @@ def get_level_data(self, stage, level):
     def get_fixture_data(self, stage, level, fixture):
         return {
             'data': fixture,
-            'editable': not fixture.is_confirmed and level == stage.current_level and self.request.user.id and stage.tournament.participations.filter(user = self.request.user).count() > 0,
+            'editable': not fixture.is_confirmed and level == stage.current_level and self.request.user.id and stage.tournament.participations.filter(participant__user = self.request.user).count() > 0,
             'has_confirmed': fixture.confirmations.filter(id = self.request.user.id).count() > 0,
         }
 
@@ -330,7 +361,7 @@ def post(self, request, *args, **kwargs):
         fixture = models.Fixture.objects.get(id = request.POST.get('fixture_id'))
 
         # Check whether the user is a participator.
-        if not request.user.id or self.object.participations.filter(user = request.user).count() == 0:
+        if not request.user.id or self.object.participations.filter(participant__user = request.user).count() == 0:
             return HttpResponseForbidden() 
 
         # Check whether the tournament is active.

tournaments/tournaments/migrations/0003_add_participant.py

@@ -0,0 +1,33 @@
+from django.db import migrations, models
+import django.db.models.deletion
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('tournaments', '0002_remove_fixture_position_fixture_extras'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='Participant',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('name', models.CharField(max_length=100)),
+                ('user', models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='participants', to='auth.User')),
+            ],
+        ),
+        migrations.AddField(
+            model_name='participation',
+            name='participant',
+            field=models.ForeignKey(default=None, on_delete=django.db.models.deletion.CASCADE, related_name='participations', to='tournaments.Participant'),
+            preserve_default=False,
+        ),
+        migrations.AlterUniqueTogether(
+            name='participation',
+            unique_together={('tournament', 'slot_id'), ('tournament', 'participant'), ('tournament', 'podium_position')},
+        ),
+        migrations.RemoveField(
+            model_name='participation',
+            name='user',
+        ),
+    ]

tournaments/tournaments/models.py

@@ -199,9 +199,17 @@ def delete_tournament_stages(sender, instance, **kwargs):
     instance.stages.non_polymorphic().all().delete()
 
 
+class Participant(models.Model):
+    user = models.ForeignKey('auth.User', on_delete = models.SET_NULL, related_name = 'participant', null = True, blank = True)
+    name = models.CharField(max_length = 100)
+
+    def __str__(self):
+        return self.name
+
+
 class Participation(models.Model):
 
-    user = models.ForeignKey('auth.User', on_delete = models.PROTECT, related_name = 'participations')
+    participant = models.ForeignKey('Participant', on_delete = models.CASCADE, related_name='participations')
     tournament = models.ForeignKey('Tournament', on_delete = models.CASCADE, related_name = 'participations')
     slot_id = models.PositiveIntegerField()
     podium_position = models.PositiveIntegerField(null = True, blank = True)
@@ -214,7 +222,7 @@ class Meta:
         ordering = ('tournament', 'slot_id')
         unique_together = [
             ('tournament', 'slot_id'),
-            ('tournament', 'user'),
+            ('tournament', 'participant'),
             ('tournament', 'podium_position'),
         ]
 
@@ -846,7 +854,7 @@ def players(self):
 
     @property
     def required_confirmations_count(self):
-        return 1 + self.mode.tournament.participations.count() // 2
+        return 1 + self.mode.tournament.participations.filter(participant__user__isnull = False).count() // 2
 
     @property
     def is_confirmed(self):