Add export for participant requests

app/grandchallenge/api/urls.py

@@ -21,6 +21,7 @@
     FollowViewSet,
     NotificationViewSet,
 )
+from grandchallenge.participants.api import RegistrationRequestViewSet
 from grandchallenge.profiles.views import UserProfileViewSet
 from grandchallenge.reader_studies.views import (
     AnswerViewSet,
@@ -65,6 +66,13 @@
 # Challenges
 router.register(r"challenges", ChallengeViewSet, basename="challenge")
 
+# Participants
+router.register(
+    r"participants/registration-requests",
+    RegistrationRequestViewSet,
+    basename="registration-request",
+)
+
 # Component Interfaces
 router.register(
     r"components/interfaces",

app/grandchallenge/participants/api.py

@@ -0,0 +1,68 @@
+from django.db.models import Prefetch
+from django_filters.rest_framework import DjangoFilterBackend
+from rest_framework import mixins
+from rest_framework.settings import api_settings
+from rest_framework.viewsets import GenericViewSet
+
+from grandchallenge.api.permissions import IsAuthenticated
+from grandchallenge.challenges.models import Challenge
+from grandchallenge.core.guardian import filter_by_permission
+from grandchallenge.participants.models import (
+    RegistrationQuestion,
+    RegistrationQuestionAnswer,
+    RegistrationRequest,
+)
+from grandchallenge.participants.renderers import (
+    RegistrationRequestCSVRenderer,
+)
+from grandchallenge.participants.serializers import (
+    RegistrationRequestSerializer,
+)
+
+
+class RegistrationRequestViewSet(mixins.ListModelMixin, GenericViewSet):
+    serializer_class = RegistrationRequestSerializer
+    permission_classes = [IsAuthenticated]
+    filter_backends = [DjangoFilterBackend]
+    filterset_fields = ["challenge__short_name"]
+    renderer_classes = (
+        *api_settings.DEFAULT_RENDERER_CLASSES,
+        RegistrationRequestCSVRenderer,
+    )
+
+    def get_queryset(self):
+        viewable_challenges = filter_by_permission(
+            queryset=Challenge.objects.all(),
+            user=self.request.user,
+            codename="change_challenge",
+            accept_user_perms=False,
+        )
+
+        # Permission check on challenges
+        queryset = RegistrationRequest.objects.filter(
+            challenge__in=viewable_challenges
+        )
+
+        viewable_questions = filter_by_permission(
+            queryset=RegistrationQuestion.objects.filter(
+                challenge__in=viewable_challenges
+            ).all(),
+            user=self.request.user,
+            codename="view_registrationquestion",
+            accept_user_perms=False,
+        )
+
+        # Prefetch with filter for viewable questions
+        queryset = queryset.prefetch_related(
+            Prefetch(
+                "registration_question_answers",
+                RegistrationQuestionAnswer.objects.filter(
+                    question__in=viewable_questions
+                ),
+            ),
+            "registration_question_answers__question",
+        )
+
+        return queryset.select_related(
+            "user__user_profile",
+        ).order_by("created")

app/grandchallenge/participants/renderers.py

@@ -0,0 +1,32 @@
+import json
+
+from rest_framework.settings import api_settings
+from rest_framework.utils.encoders import JSONEncoder
+from rest_framework_csv.renderers import PaginatedCSVRenderer
+
+
+class RegistrationRequestCSVRenderer(PaginatedCSVRenderer):
+    def flatten_dict(self, d):
+        partial_flat_dict = {}
+        for key, item in d.items():
+            if key == "registration_question_answers":
+                partial_flat_dict[key] = (
+                    self.flatten_registration_question_answers(item)
+                )
+
+        d.update(partial_flat_dict)
+        return super().flatten_dict(d)
+
+    def flatten_registration_question_answers(self, answers):
+        """
+        Answers are potentially rich JSON objects,
+         and should not be traversed during tablization
+        """
+        for answer in answers:
+            answer["answer"] = json.dumps(
+                answer["answer"],
+                cls=JSONEncoder,
+                ensure_ascii=not api_settings.UNICODE_JSON,
+                allow_nan=not api_settings.STRICT_JSON,
+            )
+        return self.flatten_item(answers)

app/grandchallenge/participants/serializers.py

@@ -0,0 +1,55 @@
+from rest_framework.fields import CharField, SerializerMethodField
+from rest_framework.serializers import ModelSerializer
+
+from grandchallenge.participants.models import (
+    RegistrationQuestion,
+    RegistrationQuestionAnswer,
+    RegistrationRequest,
+)
+from grandchallenge.profiles.serializers import UserProfileSerializer
+
+
+class RegistrationQuestionSerializer(ModelSerializer):
+
+    class Meta:
+        model = RegistrationQuestion
+        fields = (
+            "question_text",
+            "question_help_text",
+            "required",
+        )
+
+
+class RegistrationQuestionAnswerSerializer(ModelSerializer):
+
+    question = RegistrationQuestionSerializer()
+
+    class Meta:
+        model = RegistrationQuestionAnswer
+        fields = (
+            "question",
+            "answer",
+        )
+
+
+class RegistrationRequestSerializer(ModelSerializer):
+    challenge = CharField(read_only=True, source="challenge.short_name")
+    user = UserProfileSerializer(read_only=True, source="user.user_profile")
+    registration_status = SerializerMethodField(read_only=True)
+    registration_question_answers = RegistrationQuestionAnswerSerializer(
+        many=True
+    )
+
+    class Meta:
+        model = RegistrationRequest
+        fields = (
+            "challenge",
+            "user",
+            "created",
+            "changed",
+            "registration_status",
+            "registration_question_answers",
+        )
+
+    def get_registration_status(self, obj):
+        return obj.get_status_display()

app/grandchallenge/participants/templates/participants/registrationrequest_list.html

@@ -20,6 +20,14 @@
 
     <h2>Participation Requests for {{ challenge.short_name }}</h2>
 
+
+    <a class="btn btn-primary mb-4"
+        href="{% url 'api:registration-request-list' %}?format=csv&challenge__short_name={{ challenge.short_name}}"
+        download="{{ challenge.short_name }}_registration_question_answers_{{ now }}.csv"
+    >
+        <i class="fas fa-file-csv pr-1"></i> Export participation requests
+    </a>
+
     <div class="table-responsive">
         <table class="table table-hover table-borderless table-sm" id="participantsTable">
             <thead class="thead-light">

app/tests/participants_tests/test_api.py

@@ -0,0 +1,139 @@
+import pytest
+from guardian.shortcuts import remove_perm
+
+from grandchallenge.participants.models import (
+    RegistrationQuestionAnswer,
+    RegistrationRequest,
+)
+from tests.factories import (
+    ChallengeFactory,
+    RegistrationQuestionFactory,
+    RegistrationRequestFactory,
+    UserFactory,
+)
+from tests.utils import get_view_for_user
+
+
+@pytest.mark.django_db
+def test_registration_request_api_list(client):
+    ch = ChallengeFactory()
+    admin, participant, non_part_user = UserFactory.create_batch(3)
+    ch.add_admin(admin)
+    ch.add_participant(participant)
+
+    rq_0 = RegistrationQuestionFactory(challenge=ch, question_text="Foo")
+    rq_1 = RegistrationQuestionFactory(challenge=ch, question_text="No Foo")
+
+    remove_perm(
+        "view_registrationquestion", ch.admins_group, rq_1
+    )  # non-permitted viewable question
+
+    RegistrationRequestFactory(
+        challenge=ch, user=participant, status=RegistrationRequest.ACCEPTED
+    )  # Note: has no answer to the questions, should still show in the export
+
+    rr_1 = RegistrationRequestFactory(challenge=ch, user=non_part_user)
+
+    RegistrationQuestionAnswer.objects.create(
+        question=rq_0,
+        registration_request=rr_1,
+        answer="bar",
+    )
+    RegistrationQuestionAnswer.objects.create(
+        question=rq_1,
+        registration_request=rr_1,
+        answer="no bar",
+    )
+
+    response = get_view_for_user(
+        viewname="api:registration-request-list",
+        client=client,
+        user=admin,
+    )
+
+    assert response.status_code == 200, "Admin can query api for list"
+
+    result = response.json()
+
+    assert result["count"] == 2
+
+    # Check content
+    registration_request = result["results"][-1]
+
+    assert "created" in registration_request
+    assert "changed" in registration_request
+
+    assert registration_request["challenge"] == ch.short_name
+    assert registration_request["registration_status"] == "Pending"
+    assert (
+        registration_request["user"]["user"]["username"]
+        == non_part_user.username
+    )
+
+    question_answers = registration_request["registration_question_answers"]
+    assert len(question_answers) == 1
+    assert question_answers[0]["question"]["question_text"] == "Foo"
+    assert question_answers[0]["answer"] == "bar"
+
+
+@pytest.mark.django_db
+def test_registration_request_api_list_filtering(client):
+    ch_0 = ChallengeFactory()
+    admin_0, participant_0, non_part_user = UserFactory.create_batch(3)
+    ch_0.add_admin(admin_0)
+    ch_0.add_participant(participant_0)
+
+    RegistrationRequestFactory(challenge=ch_0, user=participant_0)
+    RegistrationRequestFactory(challenge=ch_0, user=non_part_user)
+
+    # Create another challenge
+    ch_1 = ChallengeFactory()
+    admin_ch1, participant_1 = UserFactory.create_batch(2)
+    ch_1.add_admin(admin_ch1)
+    ch_1.add_participant(participant_1)
+    RegistrationRequestFactory(challenge=ch_1, user=participant_1)
+
+    # First admin is admin of both
+    ch_1.add_admin(admin_0)
+
+    for usr in (participant_0, non_part_user):
+        response = get_view_for_user(
+            viewname="api:registration-request-list",
+            client=client,
+            user=usr,
+        )
+
+        assert response.status_code == 200, "Non admins can query api"
+        assert response.json()["count"] == 0, "Non admins get no challenges"
+
+    response = get_view_for_user(
+        viewname="api:registration-request-list",
+        client=client,
+        user=admin_ch1,
+    )
+    assert (
+        response.json()["count"] == 1
+    ), "Alt admin can only see one challenge"
+
+    response = get_view_for_user(
+        viewname="api:registration-request-list",
+        client=client,
+        user=admin_0,
+    )
+
+    assert response.status_code == 200, "Admin is allowed to see list"
+    assert (
+        response.json()["count"] == 3
+    ), "Admin can see both challenge' requests"
+
+    response = get_view_for_user(
+        viewname="api:registration-request-list",
+        data={"challenge__short_name": ch_1.short_name},
+        client=client,
+        user=admin_0,
+    )
+    assert response.status_code == 200, "Admin is allowed to see list"
+    result = response.json()
+
+    assert result["count"] == 1, "Admin can filter for a challenge"
+    assert result["results"][0]["challenge"] == ch_1.short_name