groups and queues, creation, update, delete ok

IdirLISN · IdirLISN · commit 00dbcfbb03d2 · 2026-02-10T13:56:33.000+01:00
diff --git a/src/apps/competitions/admin.py b/src/apps/competitions/admin.py
@@ -1,10 +1,13 @@
+from django import forms
 from django.contrib import admin
 from django.utils.translation import gettext_lazy as _
 import json
 import csv
 from django.http import HttpResponse
-from profiles.models import User
+from profiles.models import CustomGroup, User
 from . import models
+from django.contrib.auth.models import Group
+from django.contrib.admin.widgets import FilteredSelectMultiple
 
 
 # General class used to make custom filter
@@ -348,6 +351,46 @@ class PhaseExpansion(admin.ModelAdmin):
     ]
 
 
+class CustomGroupAdminForm(forms.ModelForm):
+    users = forms.ModelMultipleChoiceField(
+        queryset=User.objects.all(),
+        required=False,
+        widget=FilteredSelectMultiple("Users", is_stacked=False),
+        help_text="Add/Remove users for this group."
+    )
+
+    class Meta:
+        model = CustomGroup
+        fields = ('name', 'permissions', 'queue', 'users')
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        if self.instance and self.instance.pk:
+            self.fields['users'].initial = self.instance.user_set.all()
+
+
+admin.site.unregister(Group)
+@admin.register(CustomGroup)
+class CustomGroupAdmin(admin.ModelAdmin):
+    form = CustomGroupAdminForm
+    list_display = ('name', 'queue')
+    search_fields = ('name',)
+    filter_horizontal = ('permissions',)
+    fieldsets = (
+        (None, {'fields': ('name',)}),
+        ('Permissions', {'fields': ('permissions',)}),
+        ('Utilisateurs', {'fields': ('users',)}),
+        ('Options', {'fields': ('queue',)}),
+    )
+
+    def save_model(self, request, obj, form, change):
+        super().save_model(request, obj, form, change)
+
+    def save_related(self, request, form, formsets, change):
+        super().save_related(request, form, formsets, change)
+        form.instance.user_set.set(form.cleaned_data['users'])
+
+
 admin.site.register(models.Competition, CompetitionExpansion)
 admin.site.register(
     models.CompetitionCreationTaskStatus, CompetitionCreationTaskStatusExpansion
diff --git a/src/apps/competitions/models.py b/src/apps/competitions/models.py
@@ -13,7 +13,7 @@
 
 from celery_config import app, app_for_vhost
 from leaderboards.models import SubmissionScore
-from profiles.models import User, Organization
+from profiles.models import CustomGroup, User, Organization
 from utils.data import PathWrapper
 from utils.storage import BundleStorage
 from PIL import Image
@@ -55,6 +55,15 @@ class Competition(models.Model):
     make_programs_available = models.BooleanField(default=False)
     make_input_data_available = models.BooleanField(default=False)
 
+    participant_groups = models.ManyToManyField(
+        CustomGroup,
+        blank=True,
+        related_name='competitions',
+        verbose_name="Groupes de participants",
+        help_text="Competition owner being able to create groups of users."
+    )
+
+
     queue = models.ForeignKey('queues.Queue', on_delete=models.SET_NULL, null=True, blank=True,
                               related_name='competitions')
 
diff --git a/src/apps/competitions/urls.py b/src/apps/competitions/urls.py
@@ -13,4 +13,10 @@
     path('upload/', views.CompetitionUpload.as_view(), name="upload"),
     path('public/', views.CompetitionPublic.as_view(), name="public"),
     path('<int:pk>/detailed_results/<int:submission_id>/', views.CompetitionDetailedResults.as_view(), name="detailed_results"),
+
+    #   Groups
+    path('<int:pk>/groups/create/', views.competition_create_group, name='competition_create_group'),
+    path('<int:pk>/groups/<int:group_id>/update/', views.competition_update_group),
+    path('<int:pk>/groups/<int:group_id>/delete/', views.competition_delete_group),
+
 ]
diff --git a/src/apps/competitions/views.py b/src/apps/competitions/views.py
@@ -3,6 +3,22 @@
 from django.views.generic import TemplateView, DetailView
 
 from .models import Competition, CompetitionParticipant
+from django.core.serializers.json import DjangoJSONEncoder
+
+from django.db.models import Q
+import json
+from django.contrib.auth.decorators import login_required
+from django.views.decorators.http import require_POST
+from django.shortcuts import get_object_or_404
+from django.http import JsonResponse, HttpResponseForbidden, HttpResponseBadRequest, HttpResponseRedirect
+from django.urls import reverse
+from django.db import transaction
+from django.contrib import messages
+
+
+from profiles.models import CustomGroup, User
+from queues.models import Queue
+
 
 
 class CompetitionManagement(LoginRequiredMixin, TemplateView):
@@ -21,6 +37,47 @@ class CompetitionUpdateForm(LoginRequiredMixin, DetailView):
     template_name = 'competitions/form.html'
     queryset = Competition.objects.all()
 
+
+    def get_context_data(self, **kwargs):
+        ctx = super().get_context_data(**kwargs)
+        comp = self.object
+
+        groups_qs = CustomGroup.objects.filter(
+            Q(id__in=comp.participant_groups.values_list('id', flat=True))
+        ).select_related('queue').prefetch_related('user_set')
+
+        ctx['available_groups_json'] = json.dumps([
+            {
+                'id': g.id,
+                'name': g.name,
+                'queue': g.queue.name if g.queue else None,
+                'members': [u.username for u in g.user_set.all()],
+            }
+            for g in groups_qs
+        ], cls=DjangoJSONEncoder)
+
+        ctx['selected_group_ids_json'] = json.dumps(
+            list(comp.participant_groups.values_list('id', flat=True)),
+            cls=DjangoJSONEncoder
+        )
+
+        ctx['available_queues_json'] = json.dumps(
+            list(Queue.objects.all().values('id', 'name')),
+            cls=DjangoJSONEncoder
+        )
+
+        ctx['available_users_json'] = json.dumps(
+            list(
+                User.objects
+                    .filter(is_active=True)
+                    .values('id', 'username', 'email')
+            ),
+            cls=DjangoJSONEncoder
+        )
+
+        return ctx
+
+
     def get_object(self, *args, **kwargs):
         competition = super().get_object(*args, **kwargs)
 
@@ -76,7 +133,7 @@ def get_object(self, *args, **kwargs):
             # get participants from CompetitionParticipant where user=user and competition=competition
             is_participant = CompetitionParticipant.objects.filter(user=self.request.user, competition=competition).count() > 0
 
-        # check if secret key provided is valid
+        # check if secret key provided is valid, 
         valid_secret_key = self.request.GET.get('secret_key') == str(competition.secret_key)
 
         if (
@@ -104,3 +161,157 @@ def get_context_data(self, **kwargs):
 
 class CompetitionDetailedResults(LoginRequiredMixin, TemplateView):
     template_name = 'competitions/detailed_results.html'
+
+
+@login_required
+@require_POST
+def competition_create_group(request, pk):
+    competition = get_object_or_404(Competition, pk=pk)
+
+    user = request.user
+    if not (user.is_superuser or user == competition.created_by or user in competition.collaborators.all()):
+        return HttpResponseForbidden("Not allowed")
+
+    if request.content_type == 'application/json':
+        try:
+            payload = json.loads(request.body.decode())
+        except Exception:
+            return HttpResponseBadRequest("Invalid JSON")
+        name = (payload.get('name') or '').strip()
+        queue_id = payload.get('queue_id')
+        user_ids = payload.get('user_ids') or []
+    else:
+        name = (request.POST.get('name') or '').strip()
+        queue_id = request.POST.get('queue_id') or None
+        user_ids = request.POST.getlist('user_ids') or []
+        if not user_ids and request.POST.get('user_ids'):
+            user_ids = [u.strip() for u in request.POST.get('user_ids').split(',') if u.strip()]
+
+    if not name:
+        return HttpResponseBadRequest("Missing name")
+
+    try:
+        with transaction.atomic():
+            group = CustomGroup(name=name)
+            if queue_id:
+                try:
+                    queue = Queue.objects.get(pk=queue_id)
+                    group.queue = queue
+                except Queue.DoesNotExist:
+                    group.queue = None
+            group.save()
+
+            if user_ids:
+                # normalize to ints
+                try:
+                    user_ids_int = [int(u) for u in user_ids]
+                except Exception:
+                    user_ids_int = []
+                if user_ids_int:
+                    users_qs = User.objects.filter(pk__in=user_ids_int)
+                    group.user_set.set(users_qs)
+
+            competition.participant_groups.add(group)
+
+            members = list(group.user_set.values_list('username', flat=True))
+            group_data = {
+                'id': group.id,
+                'name': group.name,
+                'queue': group.queue.name if group.queue else None,
+                'members': members,
+            }
+    except Exception as e:
+        return HttpResponseBadRequest("Error creating group: %s" % str(e))
+
+    if request.is_ajax() or request.content_type == 'application/json' or request.headers.get('X-Requested-With') == 'XMLHttpRequest':
+        return JsonResponse({'status': 'ok', 'group': group_data})
+
+    messages.success(request, "Groupe créé")
+    return HttpResponseRedirect(reverse('competitions:edit', kwargs={'pk': competition.pk}))
+
+
+@login_required
+@require_POST
+def competition_update_group(request, pk, group_id):
+    competition = get_object_or_404(Competition, pk=pk)
+    group = get_object_or_404(CustomGroup, pk=group_id)
+
+    user = request.user
+    if not (user.is_superuser or user == competition.created_by or user in competition.collaborators.all()):
+        return HttpResponseForbidden("Not allowed")
+
+    if request.content_type == 'application/json':
+        try:
+            payload = json.loads(request.body.decode())
+        except Exception:
+            return HttpResponseBadRequest("Invalid JSON")
+        name = (payload.get('name') or '').strip()
+        queue_id = payload.get('queue_id')
+        user_ids = payload.get('user_ids', []) or []
+    else:
+        name = (request.POST.get('name') or '').strip()
+        queue_id = request.POST.get('queue_id') or None
+        user_ids = request.POST.getlist('user_ids[]') or []
+        if not user_ids and request.POST.get('user_ids'):
+            user_ids = [u.strip() for u in request.POST.get('user_ids').split(',') if u.strip()]
+
+    if not name:
+        return HttpResponseBadRequest("Missing name")
+
+    try:
+        with transaction.atomic():
+            group.name = name
+            if queue_id:
+                group.queue = Queue.objects.filter(pk=queue_id).first()
+            else:
+                group.queue = None
+            group.save()
+
+            # normalize user ids and set membership
+            try:
+                user_ids_int = [int(u) for u in user_ids]
+            except Exception:
+                user_ids_int = []
+            group.user_set.set(User.objects.filter(pk__in=user_ids_int))
+    except Exception as e:
+        return HttpResponseBadRequest("Error updating group: %s" % str(e))
+
+    resp = {
+        'status': 'ok',
+        'group': {
+            'id': group.id,
+            'name': group.name,
+            'queue': group.queue.name if group.queue else None,
+            'members': list(group.user_set.values_list('username', flat=True)),
+        }
+    }
+
+    if request.is_ajax() or request.content_type == 'application/json' or request.headers.get('X-Requested-With') == 'XMLHttpRequest':
+        return JsonResponse(resp)
+
+    messages.success(request, "Groupe modifié")
+    return HttpResponseRedirect(reverse('competitions:edit', kwargs={'pk': competition.pk}))
+
+
+@login_required
+@require_POST
+def competition_delete_group(request, pk, group_id):
+    competition = get_object_or_404(Competition, pk=pk)
+    group = get_object_or_404(CustomGroup, pk=group_id)
+
+    user = request.user
+    if not (user.is_superuser or user == competition.created_by or user in competition.collaborators.all()):
+        return HttpResponseForbidden("Not allowed")
+
+    try:
+        with transaction.atomic():
+            competition.participant_groups.remove(group)
+            group.delete()
+    except Exception as e:
+        return HttpResponseBadRequest("Error deleting group: %s" % str(e))
+
+    if request.is_ajax() or request.content_type == 'application/json' or request.headers.get('X-Requested-With') == 'XMLHttpRequest':
+        return JsonResponse({'status': 'ok', 'group_id': group_id})
+
+    messages.success(request, "Groupe supprimé")
+    return HttpResponseRedirect(reverse('competitions:edit', kwargs={'pk': competition.pk}))
diff --git a/src/apps/profiles/models.py b/src/apps/profiles/models.py
@@ -1,7 +1,9 @@
+from queues.models import Queue
 import uuid
 
 from django.contrib.auth.models import PermissionsMixin, AbstractBaseUser, UserManager
 from django.db import models
+from django.contrib.auth.models import Group
 from django.utils.timezone import now
 from django.utils.text import slugify
 from utils.data import PathWrapper
@@ -343,3 +345,22 @@ class Membership(models.Model):
 
     class Meta:
         ordering = ["date_joined"]
+
+
+class CustomGroup(Group):
+
+    queue = models.ForeignKey(Queue,
+        null=True,
+        blank=True,
+        on_delete=models.SET_NULL,
+        related_name='custom_groups',
+        verbose_name="Queue assignée au groupe",
+        help_text="Queue à utiliser pour les utilisateurs membres de ce groupe (si définie)."
+    )
+
+    class Meta:
+        verbose_name = "Group"
+        verbose_name_plural = "Groups"
+
+    def __str__(self):
+        return self.name
diff --git a/src/static/riot/competitions/editor/_participation.tag b/src/static/riot/competitions/editor/_participation.tag
diff --git a/src/templates/competitions/form.html b/src/templates/competitions/form.html
