Jobs: Added API endpoint for creating submission to a Challenge Phase

apps/jobs/admin.py

@@ -1 +1,15 @@
-# Register your models here.
+from django.contrib import admin
+
+from base.admin import TimeStampedAdmin
+
+from .models import Submission
+
+
+@admin.register(Submission)
+class SubmissionAdmin(TimeStampedAdmin):
+    list_display = ('participant_team', 'challenge_phase', 'created_by', 'status', 'is_public',
+                    'submission_number', 'submitted_at', 'input_file', 'stdout_file', 'stderr_file')
+    list_filter = ('participant_team', 'challenge_phase',
+                   'created_by', 'status', 'is_public')
+    search_fields = ('participant_team', 'challenge_phase',
+                     'created_by', 'status')

apps/jobs/models.py

@@ -1,9 +1,13 @@
 from __future__ import unicode_literals
 
+import datetime
+
 from os.path import join
 
-from django.db import models
 from django.contrib.auth.models import User
+from django.core.exceptions import PermissionDenied
+from django.db import models
+from django.db.models import Max
 
 from base.models import (TimeStampedModel, )
 from challenges.models import ChallengePhase
@@ -44,8 +48,10 @@ class Submission(TimeStampedModel):
         (SUBMITTING, SUBMITTING),
     )
 
-    participant_team = models.ForeignKey(ParticipantTeam, related_name='submissions')
-    challenge_phase = models.ForeignKey(ChallengePhase, related_name='submissions')
+    participant_team = models.ForeignKey(
+        ParticipantTeam, related_name='submissions')
+    challenge_phase = models.ForeignKey(
+        ChallengePhase, related_name='submissions')
     created_by = models.ForeignKey(User)
     status = models.CharField(max_length=30, choices=STATUS_OPTIONS)
     is_public = models.BooleanField(default=False)
@@ -66,3 +72,57 @@ def __unicode__(self):
     class Meta:
         app_label = 'jobs'
         db_table = 'submission'
+
+    def save(self, *args, **kwargs):
+
+        if not self.pk:
+            sub_num = Submission.objects.filter(
+                challenge_phase=self.challenge_phase,
+                participant_team=self.participant_team).aggregate(
+                Max('submission_number'))['submission_number__max']
+            if sub_num:
+                self.submission_number = sub_num + 1
+            else:
+                self.submission_number = 1
+
+            failed_count = Submission.objects.filter(
+                challenge_phase=self.challenge_phase,
+                participant_team=self.participant_team,
+                status=Submission.FAILED).count()
+
+            successful_count = self.submission_number - failed_count
+
+            if successful_count > self.challenge_phase.max_submissions:
+                print "Checking to see if the successful_count {0} ", \
+                    " is greater than the maximum allowed {1}".format(
+                        successful_count, self.challenge_phase.max_submissions)
+
+                print "The submission request is submitted by user {0}", \
+                    "from participant_team {1} ".format(
+                        self.created_by.pk, self.participant_team.pk)
+
+                raise PermissionDenied(
+                    "The maximum number of submissions has been reached.")
+            else:
+                print "Submission is below for user {0} form participant_team {1} for challenge_phase {2}".format(
+                    self.created_by.pk, self.participant_team.pk, self.challenge_phase.pk)
+
+            if hasattr(self.challenge_phase, 'max_submissions_per_day'):
+                submissions_done_today_count = Submission.objects.filter(
+                    challenge_phase__challenge=self.challenge_phase.challenge,
+                    participant_team=self.participant_team,
+                    challenge_phase=self.challenge_phase,
+                    submitted_at__gte=datetime.date.today()).count()
+
+                if ((submissions_done_today_count + 1 - failed_count > self.challenge_phase.max_submissions_per_day) or
+                        (self.challenge_phase.max_submissions_per_day == 0)):
+                    print 'PERMISSION DENIED'
+                    raise PermissionDenied(
+                        "The maximum number of submission for today has been reached")
+
+            self.is_public = (True if self.challenge_phase.leaderboard_public else False)
+
+            self.status = Submission.SUBMITTED
+
+        submission_instance = super(Submission, self).save(*args, **kwargs)
+        return submission_instance

apps/jobs/serializers.py

@@ -0,0 +1,24 @@
+from rest_framework import serializers
+
+from .models import Submission
+
+
+class SubmissionSerializer(serializers.ModelSerializer):
+
+    def __init__(self, *args, **kwargs):
+        context = kwargs.get('context')
+        if context:
+            created_by = context.get('request').user
+            kwargs['data']['created_by'] = created_by.pk
+
+            participant_team = context.get('participant_team').pk
+            kwargs['data']['participant_team'] = participant_team
+
+            challenge_phase = context.get('challenge_phase').pk
+            kwargs['data']['challenge_phase'] = challenge_phase
+
+        super(SubmissionSerializer, self).__init__(*args, **kwargs)
+
+    class Meta:
+        model = Submission
+        fields = ('participant_team', 'challenge_phase', 'created_by', 'status', 'input_file')

apps/jobs/urls.py

@@ -1,4 +1,9 @@
-from django.conf.urls import url  # noqa
+from django.conf.urls import url
+
+from . import views
 
 urlpatterns = [
+    url(r'challenge/(?P<challenge_id>[0-9]+)/'
+        r'challenge_phase/(?P<challenge_phase_id>[0-9]+)/submission/',
+        views.challenge_submission, name='challenge_submission'),
 ]

apps/jobs/views.py

@@ -1 +1,74 @@
-# Create your views here.
+from rest_framework import permissions, status
+from rest_framework.decorators import (api_view,
+                                       authentication_classes,
+                                       permission_classes,
+                                       throttle_classes,)
+
+from rest_framework_expiring_authtoken.authentication import (
+    ExpiringTokenAuthentication,)
+from rest_framework.response import Response
+from rest_framework.throttling import UserRateThrottle
+
+from accounts.permissions import HasVerifiedEmail
+from challenges.models import (
+    ChallengePhase,
+    Challenge,)
+from participants.models import (ParticipantTeam,)
+from participants.utils import (
+    get_participant_team_id_of_user_for_a_challenge,)
+
+from .serializers import SubmissionSerializer
+
+
+@throttle_classes([UserRateThrottle])
+@api_view(['POST'])
+@permission_classes((permissions.IsAuthenticated, HasVerifiedEmail))
+@authentication_classes((ExpiringTokenAuthentication,))
+def challenge_submission(request, challenge_id, challenge_phase_id):
+    """API Endpoint for making a submission to a challenge"""
+
+    # check if the challenge exists or not
+    try:
+        challenge = Challenge.objects.get(pk=challenge_id)
+    except Challenge.DoesNotExist:
+        response_data = {'error': 'Challenge does not exist!'}
+        return Response(response_data, status=status.HTTP_400_BAD_REQUEST)
+
+    # check if the challenge is active or not
+    if not challenge.is_active:
+        response_data = {'error': 'Challenge is not active!'}
+        return Response(response_data, status=status.HTTP_406_NOT_ACCEPTABLE)
+
+    # check if the challenge phase exists or not
+    try:
+        challenge_phase = ChallengePhase.objects.get(
+            pk=challenge_phase_id, challenge=challenge)
+    except ChallengePhase.DoesNotExist:
+        response_data = {'error': 'Challenge Phase does not exist!'}
+        return Response(response_data, status=status.HTTP_400_BAD_REQUEST)
+
+    # check if challenge phase is public and accepting solutions
+    if not challenge_phase.is_public:
+        response_data = {
+            'error': 'Sorry, cannot accept submissions since challenge phase is not public!'}
+        return Response(response_data, status=status.HTTP_406_NOT_ACCEPTABLE)
+
+    participant_team_id = get_participant_team_id_of_user_for_a_challenge(
+        request.user, challenge_id)
+    try:
+        participant_team = ParticipantTeam.objects.get(pk=participant_team_id)
+    except ParticipantTeam.DoesNotExist:
+        response_data = {'error': 'You haven\'t participated in the challenge'}
+        return Response(response_data, status=status.HTTP_403_FORBIDDEN)
+
+    serializer = SubmissionSerializer(data=request.data,
+                                      context={'participant_team': participant_team,
+                                               'challenge_phase': challenge_phase,
+                                               'request': request
+                                               })
+    if serializer.is_valid():
+        serializer.save()
+        response_data = serializer.data
+        print response_data
+        return Response(response_data, status=status.HTTP_201_CREATED)
+    return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

apps/participants/utils.py

@@ -0,0 +1,28 @@
+from challenges.models import Challenge
+
+from .models import Participant
+
+
+def is_user_part_of_participant_team(user, participant_team_id):
+    """Returns boolean if the user belongs to the participant team or not"""
+    return Participant.objects.filter(user=user, team__id=participant_team_id).exists()
+
+
+def has_participant_team_participated_in_challenge(participant_team_id, challenge_id):
+    """Returns boolean if the Participant Team participated in particular Challenge"""
+    return Challenge.objects.filter(pk=challenge_id, participant_team__id=participant_team_id).exists()
+
+
+def has_user_participated_in_challenge(user, challenge_id):
+    """Returns boolean if the user has participated in a particular challenge"""
+    participant_teams = Participant.objects.filter(user=user).values_list('teams', flat=True)
+    return Challenge.objects.filter(pk=challenge_id, participant_teams__in=participant_teams).exists()
+
+
+def get_participant_team_id_of_user_for_a_challenge(user, challenge_id):
+    """Returns the participant team object for a particular user for a particular challenge"""
+    participant_teams = Participant.objects.filter(user=user).values_list('team', flat=True)
+    for participant_team in participant_teams:
+        if Challenge.objects.filter(pk=challenge_id, participant_teams=participant_team).exists():
+            return participant_team
+    return None