def challenge_phase_list(request, challenge_pk):
try:
challenge = Challenge.objects.get(pk=challenge_pk)
except Challenge.DoesNotExist:
response_data = {'error': 'Challenge does not exist'}
return Response(response_data, status=status.HTTP_406_NOT_ACCEPTABLE)
if request.method == 'GET':
challenge_phase = ChallengePhase.objects.filter(challenge=challenge,
is_public=True)
paginator, result_page = paginated_queryset(challenge_phase, request)
serializer = ChallengePhaseSerializer(result_page, many=True)
response_data = serializer.data
return paginator.get_paginated_response(response_data)
elif request.method == 'POST':
serializer = ChallengePhaseCreateSerializer(
data=request.data, context={'challenge': challenge})
if serializer.is_valid():
serializer.save()
challenge_phase = get_challenge_phase_model(serializer.instance.pk)
serializer = ChallengePhaseSerializer(challenge_phase)
response_data = serializer.data
return Response(response_data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def get_challenge_phase_submission_analysis(request, challenge_pk,
challenge_phase_pk):
"""
Returns
1. Total number of submissions in a challenge phase
2. Number of teams which made submissions in a challenge phase
3. Number of submissions with status a)Submitting, b)Submitted, c)Running, d)Failed, e)Cancelled, f)Finished status
4. Number of flagged & public submissions in challenge phase
"""
challenge = get_challenge_model(challenge_pk)
challenge_phase = get_challenge_phase_model(challenge_phase_pk)
# Get the total submissions in a challenge phase
submissions = Submission.objects.filter(
challenge_phase=challenge_phase, challenge_phase__challenge=challenge)
total_submissions = submissions.count()
# Get the total participant teams in a challenge phase
participant_team_count = submissions.values(
'participant_team').distinct().count()
# Get flagged submission count
flagged_submissions_count = submissions.filter(is_flagged=True).count()
# Get public submission count
public_submissions_count = submissions.filter(is_public=True).count()
challenge_phase_submission_count = ChallengePhaseSubmissionAnalytics(
total_submissions, participant_team_count, flagged_submissions_count,
public_submissions_count, challenge_phase.pk)
try:
serializer = ChallengePhaseSubmissionAnalyticsSerializer(
challenge_phase_submission_count)
response_data = serializer.data
return Response(response_data, status=status.HTTP_200_OK)
except ValueError:
response_data = {'error': 'Bad request. Please try again later!'}
return Response(response_data, status=status.HTTP_400_BAD_REQUEST)
def get_challenge_phase_submission_count_by_team(request, challenge_pk,
challenge_phase_pk):
"""
Returns number of submissions done by a participant team in a challenge phase
"""
challenge = get_challenge_model(challenge_pk)
challenge_phase = get_challenge_phase_model(challenge_phase_pk)
participant_team = get_participant_team_id_of_user_for_a_challenge(
request.user, challenge.pk)
submissions = Submission.objects.filter(
challenge_phase=challenge_phase,
challenge_phase__challenge=challenge,
participant_team=participant_team)
participant_team_submissions = submissions.count()
challenge_phase_submission_count = ChallengePhaseSubmissionCount(
participant_team_submissions, challenge_phase.pk)
try:
serializer = ChallengePhaseSubmissionCountSerializer(
challenge_phase_submission_count)
response_data = serializer.data
return Response(response_data, status=status.HTTP_200_OK)
except:
response_data = {'error': "Bad request. Please try again later!"}
return Response(response_data, status=status.HTTP_400_BAD_REQUEST)
def get_last_submission_time(
request, challenge_pk, challenge_phase_pk, submission_by
):
"""
Returns the last submission time for a particular challenge phase
"""
challenge = get_challenge_model(challenge_pk)
challenge_phase = get_challenge_phase_model(challenge_phase_pk)
# To get the last submission time by a user in a challenge phase.
if submission_by == "user":
last_submitted_at = Submission.objects.filter(
created_by=request.user.pk,
challenge_phase=challenge_phase,
challenge_phase__challenge=challenge,
)
last_submitted_at = last_submitted_at.order_by("-submitted_at")[
0
].created_at
last_submitted_at = LastSubmissionDateTime(last_submitted_at)
serializer = LastSubmissionDateTimeSerializer(last_submitted_at)
return Response(serializer.data, status=status.HTTP_200_OK)
else:
response_data = {"error": "Page not found!"}
return Response(response_data, status=status.HTTP_404_NOT_FOUND)
def get_challenge_phase_submission_analysis(request, challenge_pk, challenge_phase_pk):
"""
API to fetch
1. The submissions count for challenge phase.
2. The participated team count for challenge phase.
"""
challenge = get_challenge_model(challenge_pk)
challenge_phase = get_challenge_phase_model(challenge_phase_pk)
submissions = Submission.objects.filter(
challenge_phase=challenge_phase, challenge_phase__challenge=challenge)
submission_count = submissions.count()
participant_team_count = submissions.values_list(
'participant_team', flat=True).distinct().count()
challenge_phase_submission_count = ChallengePhaseSubmissionCount(
submission_count, participant_team_count, challenge_phase.pk)
try:
serializer = ChallengePhaseSubmissionCountSerializer(challenge_phase_submission_count)
response_data = serializer.data
return Response(response_data, status=status.HTTP_200_OK)
except:
response_data = {'error': "Bad request. Please try again later!"}
return Response(response_data, status=status.HTTP_400_BAD_REQUEST)
def get_last_submission_datetime_analysis(request, challenge_pk,
challenge_phase_pk):
"""
API to fetch
1. To get the last submission time in a challenge phase.
2. To get the last submission time in a challenge.
"""
challenge = get_challenge_model(challenge_pk)
challenge_phase = get_challenge_phase_model(challenge_phase_pk)
submissions = Submission.objects.filter(
challenge_phase__challenge=challenge)
last_submission_timestamp_in_challenge = submissions.order_by(
'-submitted_at')[0].created_at
last_submission_timestamp_in_challenge_phase = submissions.filter(
challenge_phase=challenge_phase).order_by(
'-submitted_at')[0].created_at
last_submission_timestamp = LastSubmissionTimestamp(
last_submission_timestamp_in_challenge,
last_submission_timestamp_in_challenge_phase, challenge_phase.pk)
try:
serializer = LastSubmissionTimestampSerializer(
last_submission_timestamp)
response_data = serializer.data
return Response(response_data, status=status.HTTP_200_OK)
except:
response_data = {'error': 'Bad request. Please try again later!'}
return Response(response_data, status=status.HTTP_400_BAD_REQUEST)
def get_last_submission_datetime_analysis(
request, challenge_pk, challenge_phase_pk
):
"""
API to fetch
1. To get the last submission time in a challenge phase.
2. To get the last submission time in a challenge.
"""
challenge = get_challenge_model(challenge_pk)
challenge_phase = get_challenge_phase_model(challenge_phase_pk)
submissions = Submission.objects.filter(
challenge_phase__challenge=challenge
)
if not submissions:
response_data = {
"message": "You dont have any submissions in this challenge!"
}
return Response(response_data, status.HTTP_200_OK)
last_submission_timestamp_in_challenge = submissions.order_by(
"-submitted_at"
)[0].created_at
submissions_in_a_phase = submissions.filter(
challenge_phase=challenge_phase
)
if not submissions_in_a_phase:
last_submission_timestamp_in_challenge_phase = (
"You dont have any submissions in this challenge phase!"
)
else:
last_submission_timestamp_in_challenge_phase = submissions_in_a_phase.order_by(
"-submitted_at"
)[
0
].created_at
last_submission_timestamp = LastSubmissionTimestamp(
last_submission_timestamp_in_challenge,
last_submission_timestamp_in_challenge_phase,
challenge_phase.pk,
)
try:
serializer = LastSubmissionTimestampSerializer(
last_submission_timestamp
)
response_data = serializer.data
return Response(response_data, status=status.HTTP_200_OK)
except: # noqa: E722
response_data = {"error": "Bad request. Please try again later!"}
return Response(response_data, status=status.HTTP_400_BAD_REQUEST)
def change_submission_data_and_visibility(request, challenge_pk,
challenge_phase_pk, submission_pk):
"""
API Endpoint for updating the submission meta data
and changing submission visibility.
"""
# check if the challenge exists or not
challenge = get_challenge_model(challenge_pk)
# check if the challenge phase exists or not
challenge_phase = get_challenge_phase_model(challenge_phase_pk)
if not challenge.is_active:
response_data = {'error': 'Challenge is not active'}
return Response(response_data, status=status.HTTP_406_NOT_ACCEPTABLE)
# 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_pk = get_participant_team_id_of_user_for_a_challenge(
request.user, challenge_pk)
try:
participant_team = ParticipantTeam.objects.get(pk=participant_team_pk)
except ParticipantTeam.DoesNotExist:
response_data = {'error': 'You haven\'t participated in the challenge'}
return Response(response_data, status=status.HTTP_403_FORBIDDEN)
try:
submission = Submission.objects.get(participant_team=participant_team,
challenge_phase=challenge_phase,
id=submission_pk)
except Submission.DoesNotExist:
response_data = {'error': 'Submission does not exist'}
return Response(response_data, status=status.HTTP_403_FORBIDDEN)
serializer = SubmissionSerializer(submission,
data=request.data,
context={
'participant_team': participant_team,
'challenge_phase': challenge_phase,
'request': request
},
partial=True)
if serializer.is_valid():
serializer.save()
response_data = serializer.data
return Response(response_data, status=status.HTTP_200_OK)
else:
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def challenge_phase_detail(request, challenge_pk, pk):
try:
challenge = Challenge.objects.get(pk=challenge_pk)
except Challenge.DoesNotExist:
response_data = {'error': 'Challenge does not exist'}
return Response(response_data, status=status.HTTP_406_NOT_ACCEPTABLE)
try:
challenge_phase = ChallengePhase.objects.get(pk=pk)
except ChallengePhase.DoesNotExist:
response_data = {'error': 'ChallengePhase does not exist'}
return Response(response_data, status=status.HTTP_406_NOT_ACCEPTABLE)
if request.method == 'GET':
serializer = ChallengePhaseSerializer(challenge_phase)
response_data = serializer.data
return Response(response_data, status=status.HTTP_200_OK)
elif request.method in ['PUT', 'PATCH']:
if request.method == 'PATCH':
serializer = ChallengePhaseCreateSerializer(
challenge_phase,
data=request.data,
context={'challenge': challenge},
partial=True)
else:
serializer = ChallengePhaseCreateSerializer(
challenge_phase,
data=request.data,
context={'challenge': challenge})
if serializer.is_valid():
serializer.save()
challenge_phase = get_challenge_phase_model(serializer.instance.pk)
serializer = ChallengePhaseSerializer(challenge_phase)
response_data = serializer.data
return Response(response_data, status=status.HTTP_200_OK)
else:
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
elif request.method == 'DELETE':
challenge_phase.delete()
return Response(status=status.HTTP_204_NO_CONTENT)
def get_last_submission_time(request, challenge_pk, challenge_phase_pk,
submission_by):
challenge = get_challenge_model(challenge_pk)
challenge_phase = get_challenge_phase_model(challenge_phase_pk)
# To get the last submission time by a user in a challenge phase.
if submission_by == 'user':
last_submitted_at = Submission.objects.filter(
created_by=request.user.pk,
challenge_phase=challenge_phase,
challenge_phase__challenge=challenge)
last_submitted_at = last_submitted_at.order_by(
'-submitted_at')[0].created_at
last_submitted_at = LastSubmissionDateTime(last_submitted_at)
serializer = LastSubmissionDateTimeSerializer(last_submitted_at)
return Response(serializer.data, status=status.HTTP_200_OK)
else:
response_data = {'error': 'Page not found!'}
return Response(response_data, status=status.HTTP_404_NOT_FOUND)
def get_last_submission_datetime_analysis(request, challenge_pk,
challenge_phase_pk):
"""
API to fetch
1. To get the last submission time in a challenge phase.
2. To get the last submission time in a challenge.
"""
challenge = get_challenge_model(challenge_pk)
challenge_phase = get_challenge_phase_model(challenge_phase_pk)
submissions = Submission.objects.filter(
challenge_phase__challenge=challenge, challenge_phase=challenge_phase)
try:
serializer = LastSubmissionDateTimeAnalysisSerializer(submissions,
many=True)
if serializer.data:
response_data = serializer.data[0]
return Response(response_data, status=status.HTTP_200_OK)
return Response(serializer.data, status=status.HTTP_200_OK)
except:
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def get_challenge_phase_submission_analysis(request, challenge_pk,
challenge_phase_pk):
"""
API to fetch
1. The submissions count for challenge phase.
2. The participated team count for challenge phase.
"""
challenge = get_challenge_model(challenge_pk)
challenge_phase = get_challenge_phase_model(challenge_phase_pk)
submissions = Submission.objects.filter(
challenge_phase__challenge=challenge, challenge_phase=challenge_phase)
try:
serializer = ChallengePhaseSubmissionAnalysisSerializer(submissions,
many=True)
if serializer.data:
response_data = serializer.data[0]
return Response(response_data, status=status.HTTP_200_OK)
return Response(serializer.data, status=status.HTTP_200_OK)
except:
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def get_remaining_submissions(request, challenge_phase_pk, challenge_pk):
'''
Returns the number of remaining submissions that a participant can
do per day and in total to a particular challenge phase of a
challenge.
'''
# significance of get_challenge_model() here to check
# if the challenge exists or not
get_challenge_model(challenge_pk)
challenge_phase = get_challenge_phase_model(challenge_phase_pk)
participant_team_pk = get_participant_team_id_of_user_for_a_challenge(
request.user, challenge_pk)
# Conditional check for the existence of participant team of the user.
if not participant_team_pk:
response_data = {'error': 'You haven\'t participated in the challenge'}
return Response(response_data, status=status.HTTP_403_FORBIDDEN)
max_submissions_per_day_count = challenge_phase.max_submissions_per_day
max_submissions_count = challenge_phase.max_submissions
submissions_done = Submission.objects.filter(
challenge_phase__challenge=challenge_pk,
challenge_phase=challenge_phase_pk,
participant_team=participant_team_pk)
failed_submissions = submissions_done.filter(
status=Submission.FAILED)
submissions_done_today = submissions_done.filter(
submitted_at__gte=timezone.now().date())
failed_submissions_done_today = submissions_done_today.filter(
status=Submission.FAILED)
submissions_done_count = submissions_done.count()
failed_submissions_count = failed_submissions.count()
submissions_done_today_count = submissions_done_today.count()
failed_submissions_done_today_count = failed_submissions_done_today.count()
# Checks if #today's successful submission is greater than or equal to max submission per day
if ((submissions_done_today_count - failed_submissions_done_today_count) >= max_submissions_per_day_count
or (max_submissions_per_day_count == 0)):
# Get the UTC time of the instant when the above condition is true.
date_time_now = timezone.now()
# Calculate the next day's date.
date_time_tomorrow = date_time_now.date() + datetime.timedelta(1)
utc = timezone.utc
# Get the midnight time of the day i.e. 12:00 AM of next day.
midnight = utc.localize(datetime.datetime.combine(
date_time_tomorrow, datetime.time()))
# Subtract the current time from the midnight time to get the remaining time for the next day's submissions.
remaining_time = midnight - date_time_now
# Return the remaining time with a message.
response_data = {'message': 'You have exhausted today\'s submission limit',
'remaining_time': remaining_time
}
return Response(response_data, status=status.HTTP_200_OK)
else:
# Calculate the remaining submissions for today.
remaining_submissions_today_count = (max_submissions_per_day_count -
(submissions_done_today_count -
failed_submissions_done_today_count)
)
# calculate the remaining submissions from total submissions.
remaining_submission_count = max_submissions_count - \
(submissions_done_count - failed_submissions_count)
if remaining_submissions_today_count > remaining_submission_count:
remaining_submissions_today_count = remaining_submission_count
# Return the above calculated data.
response_data = {'remaining_submissions_today_count': remaining_submissions_today_count,
'remaining_submissions': remaining_submission_count
}
return Response(response_data, status=status.HTTP_200_OK)
def get_remaining_submission_for_a_phase(user, challenge_phase_pk,
challenge_pk):
"""
Returns the number of remaining submissions that a participant can
do daily, monthly and in total to a particular challenge phase of a
challenge.
"""
get_challenge_model(challenge_pk)
challenge_phase = get_challenge_phase_model(challenge_phase_pk)
participant_team_pk = get_participant_team_id_of_user_for_a_challenge(
user, challenge_pk)
# Conditional check for the existence of participant team of the user.
if not participant_team_pk:
response_data = {"error": "You haven't participated in the challenge"}
return response_data, status.HTTP_403_FORBIDDEN
max_submissions_count = challenge_phase.max_submissions
max_submissions_per_month_count = challenge_phase.max_submissions_per_month
max_submissions_per_day_count = challenge_phase.max_submissions_per_day
submissions_done = Submission.objects.filter(
challenge_phase__challenge=challenge_pk,
challenge_phase=challenge_phase_pk,
participant_team=participant_team_pk,
).exclude(status__in=submission_status_to_exclude)
submissions_done_this_month = submissions_done.filter(
submitted_at__gte=timezone.now().replace(
day=1, hour=0, minute=0, second=0, microsecond=0))
# Get the submissions_done_today by midnight time of the day
submissions_done_today = submissions_done.filter(
submitted_at__gte=timezone.now().replace(
hour=0, minute=0, second=0, microsecond=0))
submissions_done_count = submissions_done.count()
submissions_done_this_month_count = submissions_done_this_month.count()
submissions_done_today_count = submissions_done_today.count()
# Check for maximum submission limit
if submissions_done_count >= max_submissions_count:
response_data = {
"message": "You have exhausted maximum submission limit!",
"submission_limit_exceeded": True,
}
return response_data, status.HTTP_200_OK
# Check for monthy submission limit
elif submissions_done_this_month_count >= max_submissions_per_month_count:
date_time_now = timezone.now()
next_month_start_date_time = date_time_now + datetime.timedelta(
days=+30)
next_month_start_date_time = next_month_start_date_time.replace(
day=1, hour=0, minute=0, second=0, microsecond=0)
remaining_time = next_month_start_date_time - date_time_now
if submissions_done_today_count >= max_submissions_per_day_count:
response_data = {
"message":
"Both daily and monthly submission limits are exhausted!",
"remaining_time": remaining_time,
}
else:
response_data = {
"message": "You have exhausted this month's submission limit!",
"remaining_time": remaining_time,
}
return response_data, status.HTTP_200_OK
# Checks if #today's successful submission is greater than or equal to max submission per day
elif submissions_done_today_count >= max_submissions_per_day_count:
date_time_now = timezone.now()
date_time_tomorrow = date_time_now + datetime.timedelta(1)
# Get the midnight time of the day i.e. 12:00 AM of next day.
midnight = date_time_tomorrow.replace(hour=0, minute=0, second=0)
remaining_time = midnight - date_time_now
response_data = {
"message": "You have exhausted today's submission limit!",
"remaining_time": remaining_time,
}
return response_data, status.HTTP_200_OK
else:
# calculate the remaining submissions from total submissions.
remaining_submission_count = (max_submissions_count -
submissions_done_count)
# Calculate the remaining submissions for current month.
remaining_submissions_this_month_count = (
max_submissions_per_month_count -
submissions_done_this_month_count)
# Calculate the remaining submissions for today.
remaining_submissions_today_count = (max_submissions_per_day_count -
submissions_done_today_count)
remaining_submissions_this_month_count = min(
remaining_submission_count, remaining_submissions_this_month_count)
remaining_submissions_today_count = min(
remaining_submissions_this_month_count,
remaining_submissions_today_count,
)
response_data = {
"remaining_submissions_this_month_count":
remaining_submissions_this_month_count,
"remaining_submissions_today_count":
remaining_submissions_today_count,
"remaining_submissions_count": remaining_submission_count,
}
return response_data, status.HTTP_200_OK
def change_submission_data_and_visibility(request, challenge_pk,
challenge_phase_pk, submission_pk):
"""
API Endpoint for updating the submission meta data
and changing submission visibility.
"""
# check if the challenge exists or not
challenge = get_challenge_model(challenge_pk)
# check if the challenge phase exists or not
challenge_phase = get_challenge_phase_model(challenge_phase_pk)
if not challenge.is_active:
response_data = {"error": "Challenge is not active"}
return Response(response_data, status=status.HTTP_403_FORBIDDEN)
# check if challenge phase is public and accepting solutions
if not is_user_a_host_of_challenge(request.user, challenge_pk):
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_403_FORBIDDEN)
elif request.data.get("is_baseline"):
response_data = {
"error": "Sorry, you are not authorized to make this request"
}
return Response(response_data, status=status.HTTP_400_BAD_REQUEST)
participant_team_pk = get_participant_team_id_of_user_for_a_challenge(
request.user, challenge_pk)
try:
participant_team = ParticipantTeam.objects.get(pk=participant_team_pk)
except ParticipantTeam.DoesNotExist:
response_data = {"error": "You haven't participated in the challenge"}
return Response(response_data, status=status.HTTP_403_FORBIDDEN)
try:
submission = Submission.objects.get(
participant_team=participant_team,
challenge_phase=challenge_phase,
id=submission_pk,
)
except Submission.DoesNotExist:
response_data = {"error": "Submission does not exist"}
return Response(response_data, status=status.HTTP_403_FORBIDDEN)
try:
is_public = request.data["is_public"]
if is_public is True:
when_made_public = datetime.datetime.now()
request.data["when_made_public"] = when_made_public
except KeyError:
pass
serializer = SubmissionSerializer(
submission,
data=request.data,
context={
"participant_team": participant_team,
"challenge_phase": challenge_phase,
"request": request,
},
partial=True,
)
if serializer.is_valid():
serializer.save()
response_data = serializer.data
return Response(response_data, status=status.HTTP_200_OK)
else:
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def get_remaining_submissions(request, challenge_phase_pk, challenge_pk):
'''
Returns the number of remaining submissions that a participant can
do daily, monthly and in total to a particular challenge phase of a
challenge.
'''
# significance of get_challenge_model() here to check
# if the challenge exists or not
get_challenge_model(challenge_pk)
challenge_phase = get_challenge_phase_model(challenge_phase_pk)
participant_team_pk = get_participant_team_id_of_user_for_a_challenge(
request.user, challenge_pk)
# Conditional check for the existence of participant team of the user.
if not participant_team_pk:
response_data = {'error': 'You haven\'t participated in the challenge'}
return Response(response_data, status=status.HTTP_403_FORBIDDEN)
max_submissions_count = challenge_phase.max_submissions
max_submissions_per_month_count = challenge_phase.max_submissions_per_month
max_submissions_per_day_count = challenge_phase.max_submissions_per_day
submissions_done = Submission.objects.filter(
challenge_phase__challenge=challenge_pk,
challenge_phase=challenge_phase_pk,
participant_team=participant_team_pk).exclude(status=Submission.FAILED)
submissions_done_this_month = submissions_done.filter(
submitted_at__gte=timezone.now().replace(
day=1, hour=0, minute=0, second=0, microsecond=0))
# Get the submissions_done_today by midnight time of the day
submissions_done_today = submissions_done.filter(
submitted_at__gte=timezone.now().replace(
hour=0, minute=0, second=0, microsecond=0))
submissions_done_count = submissions_done.count()
submissions_done_this_month_count = submissions_done_this_month.count()
submissions_done_today_count = submissions_done_today.count()
# Check for maximum submission limit
if submissions_done_count >= max_submissions_count:
response_data = {
'message': 'You have exhausted maximum submission limit!',
'max_submission_exceeded': True
}
return Response(response_data, status=status.HTTP_200_OK)
# Check for monthy submission limit
elif submissions_done_this_month_count >= max_submissions_per_month_count:
date_time_now = timezone.now()
next_month_start_date_time = date_time_now + datetime.timedelta(
days=+30)
next_month_start_date_time = next_month_start_date_time.replace(
day=1, hour=0, minute=0, second=0, microsecond=0)
remaining_time = next_month_start_date_time - date_time_now
if submissions_done_today_count >= max_submissions_per_day_count:
response_data = {
'message':
'Both daily and monthly submission limits are exhausted!',
'remaining_time': remaining_time
}
else:
response_data = {
'message':
'You have exhausted this month\'s submission limit!',
'remaining_time': remaining_time
}
return Response(response_data, status=status.HTTP_200_OK)
# Checks if #today's successful submission is greater than or equal to max submission per day
elif submissions_done_today_count >= max_submissions_per_day_count:
date_time_now = timezone.now()
date_time_tomorrow = date_time_now + datetime.timedelta(1)
# Get the midnight time of the day i.e. 12:00 AM of next day.
midnight = date_time_tomorrow.replace(hour=0, minute=0, second=0)
remaining_time = midnight - date_time_now
response_data = {
'message': 'You have exhausted today\'s submission limit!',
'remaining_time': remaining_time
}
return Response(response_data, status=status.HTTP_200_OK)
else:
# calculate the remaining submissions from total submissions.
remaining_submission_count = max_submissions_count - submissions_done_count
# Calculate the remaining submissions for current month.
remaining_submissions_this_month_count = (
max_submissions_per_month_count -
submissions_done_this_month_count)
# Calculate the remaining submissions for today.
remaining_submissions_today_count = (max_submissions_per_day_count -
submissions_done_today_count)
remaining_submissions_this_month_count = min(
remaining_submission_count, remaining_submissions_this_month_count)
remaining_submissions_today_count = min(
remaining_submissions_this_month_count,
remaining_submissions_today_count)
response_data = {
'remaining_submissions_this_month_count':
remaining_submissions_this_month_count,
'remaining_submissions_today_count':
remaining_submissions_today_count,
'remaining_submissions': remaining_submission_count
}
return Response(response_data, status=status.HTTP_200_OK)