def group_invite_view(request):
if request.method == "GET":
try:
coder = Coder.objects.get(user=request.user)
except ObjectDoesNotExist:
return HttpResponseBadRequest()
invitations = get_dicts_with_filter(Invitation.objects,
receiver=coder,
is_accepted=False)
return JsonResponse(invitations, safe=False)
elif request.method == "POST":
try:
manager = Manager.objects.get(user=request.user)
body = request.body.decode()
receiver_id = json.loads(body)["receiver"]
group_id = json.loads(body)["group_id"]
receiver = Coder.objects.get(user__id=receiver_id)
group = Group.objects.get(pk=group_id)
except (KeyError, JSONDecodeError, ObjectDoesNotExist) as error:
return HttpResponseBadRequest(error)
invitation = Invitation(sender=manager, receiver=receiver, group=group)
invitation.save()
return JsonResponse(invitation.to_dict(), status=201)
else:
return HttpResponseNotAllowed(["GET", "POST"])
def global_report_view(request):
if request.method == 'GET':
try:
researcher = Researcher.objects.get(user=request.user)
reports = get_dicts_with_filter(GlobalReport.objects,
author=request.user)
return JsonResponse(reports, safe=False)
except ObjectDoesNotExist as error:
return HttpResponseBadRequest(error)
elif request.method == 'POST':
try:
researcher = Researcher.objects.get(user=request.user)
req_data = json.loads(request.body.decode())
title = req_data['title']
content = req_data['content']
report = GlobalReport(author=request.user,
title=title,
content=content)
report.save()
return HttpResponse(status=201)
except ObjectDoesNotExist as error:
return HttpResponseBadRequest(error)
else:
return HttpResponseNotAllowed(['GET', 'POST'])
def get_new_objective(self):
solved_solutions = get_dicts_with_filter(Solution.objects,
author_id=self.user.id)
solved_styles = {1: 0, 2: 0, 3: 0}
for solution in solved_solutions:
problem = Problem.objects.get(pk=solution['problem_id'])
solved_styles[problem.objective] += 1
objective_ranks = sorted(solved_styles.items(), key=lambda x: x[1])
return objective_ranks[0]
def problem_input_view(request, problem_id=""):
if request.method == "GET":
problem_inputs = get_dicts_with_filter(ProblemInput.objects,
problem__id=problem_id)
if len(problem_inputs) == 0:
return HttpResponseBadRequest()
return JsonResponse(problem_inputs, status=200, safe=False)
else:
return HttpResponseNotAllowed(["GET"])
def problem_output_view(request, problem_id=""):
if request.method == "GET":
problem_inputs = ProblemInput.objects.filter(problem__id=problem_id)
problem_outputs = list(
map(
lambda input: get_dicts_with_filter(
ProblemOutput.objects, problem_input__id=input.id)[0],
problem_inputs))
if len(problem_outputs) == 0:
return HttpResponseBadRequest()
return JsonResponse(problem_outputs, status=200, safe=False)
else:
return HttpResponseNotAllowed(["GET"])
def group_members_view(request, group_id):
if request.method == "GET":
try:
manager = Manager.objects.get(user=request.user)
group = Group.objects.get(pk=group_id)
if group.manager == manager:
coders = get_dicts_with_filter(Coder.objects, group=group)
return JsonResponse(coders, safe=False)
else:
return HttpResponseBadRequest()
except ObjectDoesNotExist as error:
return HttpResponseBadRequest(error)
else:
return HttpResponseNotAllowed(["GET"])
def test_get_problem_input(self):
problem = Problem(desc="For test",
input_desc="For test",
output_desc="Fore test",
pid="ITP1_6_B",
objective=1)
problem.save()
problem_input_1 = ProblemInput(problem=problem, content="input str 1")
problem_input_1.save()
problem_input_2 = ProblemInput(problem=problem, content="input str 2")
problem_input_2.save()
problem_input_3 = ProblemInput(problem=problem, content="input str 3")
problem_input_3.save()
problem_output_1 = ProblemOutput(problem_input=problem_input_1,
content="output str a")
problem_output_1.save()
problem_output_2 = ProblemOutput(problem_input=problem_input_2,
content="output str b")
problem_output_2.save()
problem_output_3 = ProblemOutput(problem_input=problem_input_3,
content="output str c")
problem_output_3.save()
problem_id = problem.to_dict()['id']
response = self.client.get(f"/api/problem/{problem_id}/input/")
self.assertEqual(response.status_code, 200)
expected_response = json.dumps(
get_dicts_with_filter(ProblemInput.objects,
problem__id=problem_id))
self.assertEqual(response.content.decode(), expected_response)
response = self.client.get("/api/problem/1000/input/")
self.assertEqual(response.status_code, 400)
response = self.client.post("/api/problem/1/input/", {})
self.assertEqual(response.status_code, 405)
def solution_view(request, problem_id):
if request.method == "GET":
solutions = get_dicts_with_filter(Solution.objects,
problem__id=problem_id,
author_id=request.user.id)
return JsonResponse(solutions, status=200, safe=False)
elif request.method == "POST":
try:
problem = Problem.objects.get(pk=problem_id)
except ObjectDoesNotExist:
return HttpResponseBadRequest()
try:
req_data = json.loads(request.body.decode())
code = req_data["code"]
erase_cnt = int(req_data["erase_cnt"])
elapsed_time = int(req_data["elapsed_time"])
evaluation = int(req_data["evaluation"])
except (KeyError, JSONDecodeError) as error:
return HttpResponseBadRequest(error)
solution = Solution(problem=problem,
code=code,
erase_cnt=erase_cnt,
elapsed_time=elapsed_time,
author_id=request.user.id,
evalutaion=evaluation)
solution.save()
SolutionReport(solution=solution,
author=request.user,
title=f"{problem.pid}_report",
code=code,
erase_cnt=erase_cnt,
elapsed_time=elapsed_time).save()
return JsonResponse({"id": solution.pk}, status=201)
else:
return HttpResponseNotAllowed(["GET", "POST"])
def group_view(request):
if request.method == "GET":
try:
manager = Manager.objects.get(user=request.user)
return JsonResponse(get_dicts_with_filter(Group.objects,
manager=manager),
safe=False)
except ObjectDoesNotExist as error:
return HttpResponseBadRequest(error)
elif request.method == "POST":
try:
manager = Manager.objects.get(user=request.user)
body = request.body.decode()
name = json.loads(body)["name"]
except (KeyError, JSONDecodeError, ObjectDoesNotExist) as error:
return HttpResponseBadRequest(error)
if Group.objects.filter(name=name).count() != 0:
return HttpResponse(status=409)
group = Group(name=name, manager=manager)
group.save()
return JsonResponse(group.to_dict(), status=201)
else:
return HttpResponseNotAllowed(["GET", "POST"])