def get(self, request, *args, **kwargs):
try:
contests = Contest.objects.all().order_by('-created_time')[:500]
serializer = ContestListSerializer(contests, many=True)
return Response(res_format(serializer.data), status=status.HTTP_200_OK)
except DatabaseError:
return Response(res_format('System error', status=Message.ERROR))
def get(self, request, *args, **kwargs):
if request.user is None or request.user.is_authenticated is False or request.user.is_admin is False:
return Response(res_format('Permission Denied',
status=Message.ERROR),
status=status.HTTP_200_OK)
support = Support.objects.all()
return Response(res_format(SupportSerializer(support, many=True).data))
def get(self, request, remote_oj, remote_id, **kwargs):
remote_oj = Controller.get_real_remote_oj(remote_oj)
if not Controller.is_support(remote_oj):
return Response(res_format('remote_oj not valid',
status=Message.ERROR),
status=status.HTTP_200_OK)
if not remote_id.isalnum():
return Response(res_format('remote_id not valid',
status=Message.ERROR),
status=status.HTTP_200_OK)
try:
problem = Problem.objects.get(remote_oj=remote_oj,
remote_id=remote_id)
if problem.request_status in [
Spider_Problem.Status.STATUS_SUBMIT_FAILED.value,
Spider_Problem.Status.STATUS_PROBLEM_NOT_EXIST.value,
Spider_Problem.Status.STATUS_NO_ACCOUNT.value,
Spider_Problem.Status.STATUS_PARSE_ERROR.value
]:
get_problem_task.delay(problem.id)
except ObjectDoesNotExist:
try:
problem = Problem(
remote_oj=remote_oj,
remote_id=remote_id,
request_status=Spider_Problem.Status.STATUS_PENDING.value)
problem.save()
get_problem_task.delay(problem.id)
except IntegrityError:
return Response(res_format('System error', Message.ERROR),
status=status.HTTP_200_OK)
return Response(res_format(ProblemSerializer(problem).data),
status=status.HTTP_200_OK)
def get(self, request, *args, **kwargs):
if request.user is None or request.user.is_authenticated is False or request.user.is_admin is False:
return Response(res_format('Permission Denied',
status=Message.ERROR),
status=status.HTTP_200_OK)
accounts = Account.objects.all().order_by('-id')
return Response(res_format(
AccountSerializer(accounts, many=True).data))
def get(self, request, **kwargs):
if request.user is None or request.user.is_authenticated is False:
return Response(res_format('Login required', status=Message.ERROR))
try:
user = UserProfile.objects.get(username=str(request.user))
return Response(res_format(user.hook))
except DatabaseError:
return Response(res_format('System error', status=Message.ERROR))
def get(self, request, **kwargs):
if request.user and request.user.is_authenticated:
user_profile = UserProfile.objects.get(username=request.user)
serializer = UserProfileSerializer(user_profile)
res_data = serializer.data
res_data['email'] = hashlib.md5(
str(res_data['email']).encode('utf-8')).hexdigest()
return Response(res_format(res_data, status=Message.SUCCESS))
return Response(res_format('Login required', status=Message.ERROR))
def post(self, request, **kwargs):
register = RegisterSerializer(data=request.data)
if register.is_valid():
if register.save():
return Response(res_format('Register success'))
else:
return Response(
res_format('System error', status=Message.ERROR))
return Response(res_format(register.errors, status=Message.ERROR))
def post(self, request, **kwargs):
if request.user is None or request.user.is_authenticated is False:
return Response(res_format('Login required', status=Message.ERROR))
serializer = HookSerializer(data=request.data)
if serializer.is_valid():
if serializer.save(str(request.user)):
return Response(res_format('Update hook url success'))
return Response(res_format('System error', status=Message.ERROR))
return Response(res_format('Post data not valid',
status=Message.ERROR))
def get(self, request, *args, **kwargs):
if request.user and request.user.is_authenticated:
try:
user = UserProfile.objects.get(username=request.user)
return Response(
res_format(UserProfileSerializer(user).data,
status=Message.SUCCESS))
except:
return Response(res_format('System Error', Message.ERROR))
return Response(res_format('Login required', Message.ERROR))
def get(self, request, submission_id, *args, **kwargs):
try:
submission = Submission.objects.get(id=submission_id)
if submission.user == str(request.user):
return Response(res_format(VerdictSerializer(submission).data), status=status.HTTP_200_OK)
else:
res_data = VerdictSerializer(submission).data
res_data['code'] = None
return Response(res_format(res_data), status=status.HTTP_200_OK)
except ObjectDoesNotExist:
return Response(res_format('submission not exist', status=Message.ERROR), status=status.HTTP_200_OK)
def post(self,request,**kwargs):
serializers = LoginSerializer(data=request.data)
if serializers.is_valid():
user = serializers.login(request)
if user:
return Response(res_format(UserProfileSerializers(user).data,status=Message.SUCCESS),
status=status.HTTP_200_OK)
else:
return Response(res_format('Incorrect username or password',status=Message.ERROR))
print('serializers.errors')
return Response(res_format(serializers.errors,Message.ERROR))
def get(self, request, *args, **kwargs):
try:
support = list({
item.oj_name
for item in Support.objects.filter(oj_enable=True)
})
support.sort()
return Response(res_format(support), status=status.HTTP_200_OK)
except DatabaseError:
return Response(res_format('System error', status=Message.ERROR),
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def get(self, request, *args, **kwargs):
try:
if request.GET.get('user'):
submissions = Submission.objects.filter(user=request.GET.get('user')).order_by('-create_time')[:500]
return Response(res_format(SubmissionListSerializer(submissions, many=True).data),
status=status.HTTP_200_OK)
submissions = Submission.objects.all().order_by('-create_time')[:500]
return Response(res_format(SubmissionListSerializer(submissions, many=True).data),
status=status.HTTP_200_OK)
except DatabaseError:
return Response(res_format('System error', status=Message.ERROR),
status=status.HTTP_200_OK)
def get(self, request, problem_id, param=None, **kwargs):
try:
problem = Problem.objects.get(id=problem_id)
if param == 'html':
return HttpResponse(problem.html)
return Response(res_format(ProblemSerializer(problem).data),
status=status.HTTP_200_OK)
except ObjectDoesNotExist:
return Response(res_format('problem not exist',
status=Message.ERROR),
status=status.HTTP_200_OK)
def post(self, request, *args, **kwargs):
if request.user is None or request.user.is_authenticated is False or request.user.is_admin is False:
return Response(res_format('Admin required', status=Message.ERROR),
status=status.HTTP_200_OK)
try:
accounts = Account.objects.all()
for remote_oj in {account.oj_name for account in accounts}:
update_language_task.delay(remote_oj)
return Response(res_format('Fresh successfully'),
status=status.HTTP_200_OK)
except DatabaseError:
return Response(res_format('Fresh error', status=Message.ERROR),
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def post(self, request, *args, **kwargs):
if request.user is None or request.user.is_authenticated is False:
return Response(res_format('Login required', status=Message.ERROR), status=status.HTTP_200_OK)
if request.user.is_admin is False:
return Response(res_format('Admin required', status=Message.ERROR), status=status.HTTP_200_OK)
serializer = ContestSerializer(data=request.data)
if serializer.is_valid():
contest = serializer.save(request.user)
if contest:
return Response(res_format(contest.id), status=status.HTTP_200_OK)
return Response(res_format('System error', status=Message.ERROR), status=status.HTTP_200_OK)
return Response(res_format(serializer.errors, status=Message.ERROR), status=status.HTTP_200_OK)
def post(self, request, *args, **kwargs):
if request.user is None or request.user.is_authenticated is False or request.user.is_admin is False:
return Response(res_format('Permission Denied',
status=Message.ERROR),
status=status.HTTP_200_OK)
request_type = request.GET.get('type')
if request_type == 'enable':
serializer = UpdateEnableSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response(res_format('success'))
else:
print(serializer.errors)
return Response(res_format('error', Message.ERROR))
elif request_type == 'reuse':
serializer = UpdateReuseSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response(res_format('success'))
else:
print(serializer.errors)
return Response(res_format('error', Message.ERROR))
elif request_type == 'fresh':
platform = request.GET.get('platform')
if platform:
update_oj_status.delay(platform)
else:
try:
for item in Core.get_supports():
if not Support.objects.filter(oj_name=item):
Support.objects.create(oj_name=item).save()
Support.objects.filter(oj_name=item).update(
oj_status='PENDING')
update_oj_status.delay(item)
except Exception as e:
print(e)
return Response(res_format('error', Message.ERROR))
return Response(res_format('success'))
elif request_type == 'proxies':
serializer = UpdateProxiesSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response(res_format('success'))
else:
return Response(res_format('error', Message.ERROR))
support = list(
{item.oj_name
for item in Support.objects.filter(oj_enable=True)})
support.sort()
return Response(res_format(support), status=status.HTTP_200_OK)
def post(self, request, *args, **kwargs):
if request.user and request.user.is_authenticated:
serializer = ChangePasswordSerializer(data=request.data)
if serializer.is_valid():
user = serializer.save()
if user is not None:
return Response(
res_format(UserProfileSerializer(user).data,
status=Message.SUCCESS))
return Response(
res_format('Change password failed', status=Message.ERROR))
return Response(res_format(serializer.errors,
status=Message.ERROR))
return Response(res_format('Login required', status=Message.ERROR))
def post(self, request, **kwargs):
if request.user is None or request.user.is_authenticated is False:
return Response(res_format('Login required', status=Message.ERROR))
serializer = HookSerializer(data=request.data)
if serializer.is_valid():
try:
url = serializer.validated_data['hook']
UserProfile.objects.filter(username=request.user).update(
hook=url)
return Response(res_format('success'))
except:
pass
return Response(res_format('System error', status=Message.ERROR))
return Response(res_format('Post data not valid',
status=Message.ERROR))
def get(self, request, raw_oj_name, *args, **kwargs):
remote_oj = control.Controller.get_real_remote_oj(raw_oj_name)
if control.Controller.is_support(remote_oj):
try:
languages = Language.objects.filter(oj_name=remote_oj)
return Response(res_format(
LanguagesSerializer(languages, many=True).data),
status=status.HTTP_200_OK)
except DatabaseError:
return Response(res_format('System error',
status=Message.ERROR),
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
return Response(res_format('we do not support it',
status=Message.ERROR),
status=status.HTTP_400_BAD_REQUEST)
def delete(self, request, *args, **kwargs):
if request.user is None or request.user.is_authenticated is False or request.user.is_admin is False:
return Response(res_format('Permission Denied',
status=Message.ERROR),
status=status.HTTP_200_OK)
platform = request.GET.get('platform')
username = request.GET.get('username')
if platform and username:
try:
Account.objects.filter(oj_name=platform,
oj_username=username).delete()
return Response(res_format('success'))
except:
pass
return Response(res_format('error', Message.ERROR))
def post(self, request, submission_id, *args, **kwargs):
try:
submission = Submission.objects.get(id=submission_id)
if submission.status == config.Result.Status.STATUS_SPIDER_ERROR.value:
submission.status = config.Result.Status.STATUS_PENDING.value
submission.save()
submit_task.delay(submission_id)
return Response(res_format('rejudge submit success'), status=status.HTTP_200_OK)
elif submission.status == config.Result.Status.STATUS_RESULT_SUCCESS.value and \
submission.verdict == config.Result.Verdict.VERDICT_RUNNING.value:
reload_result_task.delay(submission.id)
return Response(res_format('reload submit success'), status=status.HTTP_200_OK)
return Response(res_format('nothing has done'), status=status.HTTP_200_OK)
except ObjectDoesNotExist:
return Response(res_format('system error', status=Message.ERROR), status=status.HTTP_200_OK)
except DatabaseError:
return Response(res_format('reload failed', status=Message.ERROR), status=status.HTTP_200_OK)
def post(self, request, *args, **kwargs):
if request.user is None or request.user.is_authenticated is False or request.user.is_admin is False:
return Response(res_format('Permission Denied',
status=Message.ERROR),
status=status.HTTP_200_OK)
serializer = AccountSerializer(data=request.data)
if serializer.is_valid():
if serializer.save():
update_language_task.delay(
serializer.validated_data['oj_name'])
return Response(res_format('success'),
status=status.HTTP_200_OK)
else:
return Response(res_format('error', status=Message.ERROR),
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
else:
return Response(res_format(serializer.errors,
status=Message.ERROR),
status=status.HTTP_400_BAD_REQUEST)
def post(self, request, *args, **kwargs):
if request.user is None or request.user.is_authenticated is False or request.user.is_admin is False:
return Response(res_format('Permission Denied',
status=Message.ERROR),
status=status.HTTP_200_OK)
serializer = AccountSerializer(data=request.data)
if serializer.is_valid():
if serializer.save():
return Response(res_format('operation success',
status=Message.SUCCESS),
status=status.HTTP_200_OK)
else:
return Response(res_format('operation failed',
status=Message.ERROR),
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
else:
return Response(res_format(serializer.errors,
status=Message.ERROR),
status=status.HTTP_400_BAD_REQUEST)
def get(self, request, *args, **kwargs):
today = datetime.fromisoformat(
datetime_safe.datetime.today().strftime("%Y-%m-%d"))
counts = []
for offset in range(6, -1, -1):
counts.append(
Submission.objects.filter(create_time__gte=today -
timedelta(days=offset),
create_time__lt=today -
timedelta(days=offset - 1)).count())
return Response(res_format(counts), status=status.HTTP_200_OK)
def get(self, request, remote_oj, remote_id, **kwargs):
last_submit_time = request.session.get('last_refresh_time', None)
if last_submit_time and (
datetime.now() -
datetime.fromtimestamp(last_submit_time)).seconds < 5:
return Response(res_format("Cannot Refresh within five seconds",
status=Message.ERROR),
status=status.HTTP_200_OK)
request.session['last_refresh_time'] = datetime.now().timestamp()
try:
problem = Problem.objects.get(remote_oj=remote_oj,
remote_id=remote_id)
problem.request_status = Spider_Problem.Status.STATUS_PENDING.value
problem.save()
get_problem_task.delay(problem.id)
return Response(res_format(ProblemSerializer(problem).data),
status=status.HTTP_200_OK)
except ObjectDoesNotExist:
return Response(res_format('System error', Message.ERROR),
status=status.HTTP_200_OK)
def get(self, request, remote_oj, remote_id, **kwargs):
if remote_oj not in list({item.oj_name for item in Support.objects.filter(oj_enable=True)}):
return Response(
res_format('remote_oj not valid', status=Message.ERROR),
status=status.HTTP_200_OK)
if not remote_id.isalnum():
return Response(
res_format('remote_id not valid', status=Message.ERROR),
status=status.HTTP_200_OK)
if request.GET.get('fresh') and request.GET.get('html'):
return Response(res_format('\"fresh\" and \"html\" cannot exist together', Message.ERROR),
status=status.HTTP_200_OK)
if request.GET.get('fresh'):
last_submit_time = request.session.get('last_fresh_time', None)
if last_submit_time and (datetime.now() - datetime.fromtimestamp(last_submit_time)).seconds < 5:
return Response(res_format("Cannot fresh within five seconds", status=Message.ERROR),
status=status.HTTP_200_OK)
request.session['last_fresh_time'] = datetime.now().timestamp()
try:
problem = Problem.objects.get(remote_oj=remote_oj, remote_id=remote_id)
problem.request_status = config.Problem.Status.STATUS_PENDING.value
problem.save()
get_problem_task.delay(problem.id)
return Response(res_format(ProblemSerializer(problem).data), status=status.HTTP_200_OK)
except ObjectDoesNotExist:
return Response(res_format('System error', Message.ERROR), status=status.HTTP_200_OK)
if request.GET.get('html'):
try:
problem = Problem.objects.get(remote_oj=remote_oj, remote_id=remote_id)
return HttpResponse(problem.html)
except:
return Response(res_format('', status=Message.ERROR))
try:
problem = Problem.objects.get(remote_oj=remote_oj, remote_id=remote_id)
if problem.request_status == config.Problem.Status.STATUS_RETRYABLE.value:
get_problem_task.delay(problem.id)
except ObjectDoesNotExist:
try:
problem = Problem(remote_oj=remote_oj, remote_id=remote_id,
request_status=config.Problem.Status.STATUS_PENDING.value)
problem.save()
get_problem_task.delay(problem.id)
except IntegrityError:
return Response(res_format('System error', Message.ERROR), status=status.HTTP_200_OK)
return Response(res_format(ProblemSerializer(problem).data), status=status.HTTP_200_OK)
def get(self, request, *args, **kwargs):
problems = Problem.objects.filter(
Q(remote_oj__in=[item.oj_name for item in Support.objects.filter(oj_enable=True)]) & Q(
html__isnull=False)).order_by('-update_time')
if request.GET.get('remote_oj'):
remote_oj = request.GET.get('remote_oj')
problems = problems.filter(remote_oj=remote_oj)
if request.GET.get('remote_id'):
problems = problems.filter(remote_id__contains=request.GET.get('remote_id'))
if request.GET.get('title'):
problems = problems.filter(title__contains=request.GET.get('title'))
return Response(res_format(ProblemListSerializer(problems, many=True).data), status=status.HTTP_200_OK)
def post(self, request, submission_id, *args, **kwargs):
if request.user is None or request.user.is_authenticated is False:
return Response(res_format('Login required', status=Message.ERROR),
status=status.HTTP_200_OK)
try:
submission = Submission.objects.get(id=submission_id)
if submission.status in {
config.Result.Status.STATUS_NO_ACCOUNT.value,
config.Result.Status.STATUS_NETWORK_ERROR.value
}:
submission.status = config.Result.Status.STATUS_PENDING.value
submission.save()
submit_task.delay(submission_id)
return Response(res_format('rejudge submit success'),
status=status.HTTP_200_OK)
except ObjectDoesNotExist:
return Response(res_format('System error', status=Message.ERROR),
status=status.HTTP_200_OK)
except DatabaseError:
return Response(res_format('rejudge failed', status=Message.ERROR),
status=status.HTTP_200_OK)
def get(self, request, *args, **kwargs):
remote_oj = request.GET.get('platform')
if remote_oj is None:
if request.user is None or request.user.is_authenticated is False or request.user.is_admin is False:
return Response(res_format('Admin required',
status=Message.ERROR),
status=status.HTTP_200_OK)
try:
languages = Language.objects.all()
return Response(res_format(
LanguagesSerializer(languages, many=True).data),
status=status.HTTP_200_OK)
except DatabaseError:
return Response(res_format('System error',
status=Message.ERROR),
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
if Core.is_support(remote_oj):
try:
languages = Language.objects.filter(oj_name=remote_oj)
return Response(res_format(
LanguagesSerializer(languages, many=True).data),
status=status.HTTP_200_OK)
except DatabaseError:
return Response(res_format('System error',
status=Message.ERROR),
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
return Response(res_format('we do not support it',
status=Message.ERROR),
status=status.HTTP_400_BAD_REQUEST)
