Ross
1101 lines
33 KiB
Python
1101 lines
33 KiB
Python
from django.forms.models import model_to_dict
|
|
from django.shortcuts import render, get_object_or_404, redirect
|
|
from django.views.decorators.csrf import csrf_exempt
|
|
from django import forms
|
|
|
|
# from django.contrib.auth.models import User
|
|
from django.contrib.auth.decorators import login_required, user_passes_test
|
|
from django.contrib.auth.models import User
|
|
from django.core.exceptions import FieldError, PermissionDenied
|
|
|
|
from django.contrib.auth.mixins import LoginRequiredMixin
|
|
from django.views.generic.detail import DetailView
|
|
|
|
from django.views.generic.edit import CreateView, UpdateView, DeleteView
|
|
from django.views.generic import ListView
|
|
|
|
from django.db.models.functions import Lower
|
|
|
|
from django.core.cache import cache
|
|
|
|
from django.urls import reverse_lazy, reverse
|
|
|
|
from django.http import Http404, JsonResponse
|
|
|
|
from django.http import HttpResponseRedirect, HttpResponse
|
|
|
|
from dal import autocomplete
|
|
|
|
from .forms import (
|
|
AnatomyAnswerForm,
|
|
AnswerFormSet,
|
|
AnswerUpdateFormSet,
|
|
BodyPartForm,
|
|
ExaminationForm,
|
|
MarkAnatomyQuestionForm,
|
|
AnatomyQuestionForm,
|
|
StructureForm,
|
|
ExamForm,
|
|
)
|
|
from .models import (
|
|
AnatomyQuestion,
|
|
BodyPart,
|
|
CidUserAnswer,
|
|
# Examination,
|
|
Structure,
|
|
Exam,
|
|
Answer,
|
|
# HalfMarkAnswers,
|
|
# IncorrectAnswers,
|
|
)
|
|
from generic.models import Examination
|
|
from generic.views import ExamCloneMixin, ExamViews, GenericViewBase
|
|
from reversion.views import RevisionMixin
|
|
|
|
from .decorators import user_is_author_or_anatomy_checker
|
|
|
|
from .tables import AnatomyQuestionTable, AnatomyUserAnswerTable
|
|
from .filters import AnatomyQuestionFilter, AnatomyUserAnswerFilter
|
|
|
|
from django_tables2 import SingleTableView, SingleTableMixin
|
|
from django_filters.views import FilterView
|
|
|
|
from collections import defaultdict
|
|
import os
|
|
import json
|
|
import statistics
|
|
import plotly.express as px
|
|
|
|
from helpers.images import image_as_base64
|
|
|
|
from django.template.defaulttags import register
|
|
|
|
from generic.mixins import SuperuserRequiredMixin
|
|
|
|
from rest_framework import viewsets, permissions
|
|
|
|
from .serializers import ExamSerializer
|
|
|
|
|
|
class AuthorOrCheckerRequiredMixin(object):
|
|
def get_object(self, *args, **kwargs):
|
|
obj = super().get_object(*args, **kwargs)
|
|
if self.request.user.groups.filter(name="anatomy_checker").exists():
|
|
return obj
|
|
if self.request.user not in obj.author.all():
|
|
raise PermissionDenied() # or Http404
|
|
return obj
|
|
|
|
|
|
@register.filter
|
|
def get_item(dictionary, key):
|
|
return dictionary.get(key)
|
|
|
|
|
|
def user_is_admin(user):
|
|
if user:
|
|
if user.pk == 1:
|
|
return True
|
|
return False
|
|
|
|
|
|
def question_list(request):
|
|
questions = AnatomyQuestion.objects.all()
|
|
|
|
if not request.user.groups.filter(name="anatomy_checker").exists():
|
|
questions = questions.filter(open_access=False)
|
|
# raise PermissionDenied()
|
|
|
|
return render(request, "anatomy/question_list.html", {"questions": questions})
|
|
|
|
|
|
@login_required
|
|
def answer_question(request, pk):
|
|
question = get_object_or_404(AnatomyQuestion, pk=pk)
|
|
answer = question.user_answers.filter(
|
|
user=request.user
|
|
).first() # .filter(user=User)
|
|
if request.method == "POST":
|
|
if answer:
|
|
form = AnatomyAnswerForm(request.POST, instance=answer)
|
|
else:
|
|
form = AnatomyAnswerForm(request.POST)
|
|
if form.is_valid():
|
|
answer = form.save(commit=False)
|
|
answer.user = request.user
|
|
answer.question = question
|
|
# answer.published_date = timezone.now()
|
|
answer.save()
|
|
return redirect("question_detail", pk=pk)
|
|
else:
|
|
form = AnatomyAnswerForm(instance=answer)
|
|
return render(
|
|
request, "anatomy/answer_question.html", {"form": form, "question": question}
|
|
)
|
|
|
|
|
|
#@login_required
|
|
#def exam_take(request, pk, sk):
|
|
# """
|
|
# Allows taking of the exam on the django server (when logged in)
|
|
#
|
|
# No longer used (deprecated in favour of using RTS)
|
|
# """
|
|
# exam = get_object_or_404(Exam, pk=pk)
|
|
#
|
|
# questions = exam.exam_questions.all()
|
|
#
|
|
# try:
|
|
# question = questions[sk]
|
|
# except IndexError:
|
|
# raise Http404("Exam question does not exist")
|
|
#
|
|
# n = sk
|
|
#
|
|
# question_details = {
|
|
# "total": len(questions),
|
|
# "current": n + 1,
|
|
# }
|
|
#
|
|
# # Get data for flagged
|
|
# # answered_questions = UserAnswer.objects.filter(user=request.user).values_list("question__pk", flat=True)
|
|
# user_answer_data = UserAnswer.objects.filter(user=request.user).values_list(
|
|
# "question__pk", "answer", "flagged"
|
|
# )
|
|
# # flagged_questions = UserAnswer.objects.filter(user=request.user, flagged=True).values_list("question__pk", flat=True)
|
|
# # flagged_questions I= UserAnswer.filter(user=request.user, ).values_list("question__pk", flat=True)
|
|
#
|
|
# answered_questions = set()
|
|
# flagged_questions = set()
|
|
# for ans_pk, answer, flagged in user_answer_data:
|
|
# if len(answer.strip()) > 0:
|
|
# answered_questions.add(ans_pk)
|
|
# if flagged:
|
|
# flagged_questions.add(ans_pk)
|
|
#
|
|
# # u = question.user_answers
|
|
# answer = question.user_answers.filter(
|
|
# user=request.user
|
|
# ).first() # .filter(user=User)
|
|
# if request.method == "POST":
|
|
# if answer:
|
|
# form = AnatomyAnswerForm(request.POST, instance=answer)
|
|
# else:
|
|
# form = AnatomyAnswerForm(request.POST)
|
|
# if form.is_valid():
|
|
# answer = form.save(commit=False)
|
|
# answer.user = request.user
|
|
# answer.question = question
|
|
# # answer.published_date = timezone.now()
|
|
# answer.save()
|
|
# if "next" in request.POST:
|
|
# return redirect("anatomy:exam_take", pk=pk, sk=n + 1)
|
|
# elif "previous" in request.POST:
|
|
# return redirect("anatomy:exam_take", pk=pk, sk=n - 1)
|
|
# else:
|
|
# form = AnatomyAnswerForm(instance=answer)
|
|
# return render(
|
|
# request,
|
|
# "anatomy/exam.html",
|
|
# {
|
|
# "exam": exam,
|
|
# "form": form,
|
|
# "question": question,
|
|
# "question_details": question_details,
|
|
# "questions": questions,
|
|
# "flagged_questions": flagged_questions,
|
|
# "answered_questions": answered_questions,
|
|
# "answer": answer,
|
|
# },
|
|
# )
|
|
|
|
|
|
#def flag_question(request):
|
|
# pk = request.GET.get("pk", None)
|
|
# ans = UserAnswer.objects.filter(user=request.user, question__pk=pk).first()
|
|
# ans.flagged = not ans.flagged
|
|
# ans.save()
|
|
# data = {"flagged": ans.flagged}
|
|
# return JsonResponse(data)
|
|
|
|
|
|
def loadJsonAnswer(answer):
|
|
# Backend eid is just the object pk number
|
|
# in the frontend this is appended with the type
|
|
# e.g. anatomy/1
|
|
|
|
# TODO Update to only allow valid CIDs
|
|
eid = int(answer["eid"].split("/")[1])
|
|
# As access is not restricted make sure the data appears valid
|
|
if (not isinstance(answer["cid"], int)) or (
|
|
not isinstance(eid, int) or (not isinstance(answer["ans"], str))
|
|
):
|
|
return False, JsonResponse(
|
|
{"success": False, "error": "cid or eid or answers not defined"}
|
|
)
|
|
|
|
# The model should catch invalid data but this should be less intensive
|
|
max_int = 999999999999999999999
|
|
if answer["cid"] > max_int or eid > max_int:
|
|
return False, JsonResponse({"success": False, "error": "invalid cid"})
|
|
|
|
exam = get_object_or_404(Exam, pk=eid)
|
|
|
|
if not exam.check_cid_user(answer["cid"], answer["passcode"]):
|
|
return False, JsonResponse({"success": False, "error": "invalid cid / passcode"})
|
|
|
|
# if not exam.active:
|
|
# return False, JsonResponse(
|
|
# {"success": False, "error": "No active exam: {}".format(eid)}
|
|
# )
|
|
|
|
exiting_answers = CidUserAnswer.objects.filter(
|
|
question__id=answer["qid"], exam__id=eid, cid=answer["cid"]
|
|
)
|
|
|
|
if not exiting_answers:
|
|
ans = CidUserAnswer(answer=answer["ans"], cid=answer["cid"])
|
|
ans.question_id = answer["qid"]
|
|
ans.exam_id = eid
|
|
ans.score = Answer.MarkOptions.UNMARKED
|
|
|
|
ans.full_clean()
|
|
|
|
ans.save()
|
|
else:
|
|
# Update an existing answer
|
|
# should never be more than one (famous last words)
|
|
ans = exiting_answers[0]
|
|
ans.answer = answer["ans"]
|
|
ans.score = Answer.MarkOptions.UNMARKED
|
|
ans.full_clean()
|
|
ans.save()
|
|
|
|
return True, None
|
|
|
|
|
|
# @csrf_exempt
|
|
# def postExamAnswers(request):
|
|
# if request.is_ajax and request.method == "POST":
|
|
#
|
|
# n = 0
|
|
# # horrible but it works
|
|
# #for k in request.POST.dict():
|
|
#
|
|
# for answer in json.loads(request.POST.get("answers")):
|
|
# ret = loadJsonAnswer(answer)
|
|
#
|
|
# if ret is not True:
|
|
# return ret
|
|
# n = n + 1
|
|
#
|
|
# # print(UserAnswer.objects.filter(exam__id=q["eid"]))
|
|
# # print(request.urlencode())
|
|
#
|
|
# return JsonResponse({"success": True, "question_count": n})
|
|
# return JsonResponse({"success": False, "error": "Invalid data"})
|
|
#
|
|
# # return render(request, "anatomy/exam.html", {"exam" : exam, "question" : question})
|
|
|
|
|
|
@login_required
|
|
def mark_all(request, exam_pk, sk):
|
|
return mark(request, exam_pk, sk, unmarked_exam_answers_only=False)
|
|
|
|
|
|
@login_required
|
|
def mark_review(request, exam_pk, sk):
|
|
return mark(request, exam_pk, sk, unmarked_exam_answers_only=False, review=True)
|
|
|
|
|
|
# @user_passes_test(user_is_admin, login_url="/accounts/login")
|
|
@login_required
|
|
def mark(request, exam_pk, sk, unmarked_exam_answers_only=True, review=False):
|
|
exam = get_object_or_404(Exam, pk=exam_pk)
|
|
|
|
if not exam.exam_mode:
|
|
raise Http404("Packet not in exam mode")
|
|
|
|
mark_url = "anatomy:mark"
|
|
if review:
|
|
mark_url = "anatomy:mark_review"
|
|
elif not unmarked_exam_answers_only:
|
|
mark_url = "anatomy:mark_all"
|
|
|
|
questions = exam.exam_questions.all()
|
|
|
|
n = sk
|
|
|
|
question_details = {
|
|
"total": len(questions),
|
|
"current": n + 1,
|
|
}
|
|
|
|
try:
|
|
question = questions[sk]
|
|
except IndexError:
|
|
raise Http404("Exam question does not exist")
|
|
|
|
# unmarked_user_answers = question.get_unmarked_user_answers()
|
|
|
|
if request.method == "POST":
|
|
|
|
form = MarkAnatomyQuestionForm(request.POST)
|
|
# *******************************
|
|
# TODO: convert to JSON request
|
|
# *******************************
|
|
if form.is_valid():
|
|
# If skip button is pressed skip the question without marking
|
|
if "skip" in request.POST:
|
|
return redirect(mark_url, exam_pk=exam_pk, sk=n + 1)
|
|
|
|
cd = form.cleaned_data
|
|
|
|
marked_answers = json.loads(cd.get("marked_answers"))
|
|
|
|
# This should probably use json (or something else...)
|
|
# ajax.....
|
|
to_run = (
|
|
("correct", Answer.MarkOptions.CORRECT),
|
|
("half-correct", Answer.MarkOptions.HALF_MARK),
|
|
("incorrect", Answer.MarkOptions.INCORRECT),
|
|
)
|
|
|
|
for status_string, status in to_run:
|
|
for ans in marked_answers[status_string]:
|
|
ans = ans.strip()
|
|
if ans == "":
|
|
continue
|
|
|
|
a = Answer.objects.filter(
|
|
answer__iexact=ans, question_id=question.pk
|
|
).first()
|
|
|
|
if a is None:
|
|
a = Answer()
|
|
a.question_id = question.pk
|
|
a.answer = ans
|
|
|
|
a.status = status
|
|
a.save()
|
|
|
|
if "next" in request.POST:
|
|
return redirect(mark_url, exam_pk=exam_pk, sk=n + 1)
|
|
elif "previous" in request.POST:
|
|
return redirect(mark_url, exam_pk=exam_pk, sk=n - 1)
|
|
|
|
# Reset user answers (relies on the functional javascript)
|
|
unmarked_user_answers = set()
|
|
else:
|
|
form = MarkAnatomyQuestionForm()
|
|
|
|
# correct_answers = question.answers.filter(status=Answer.MarkOptions.CORRECT)
|
|
# half_mark_answers = question.answers.filter(status=Answer.MarkOptions.HALF_MARK)
|
|
# incorrect_answers = question.answers.filter(status=Answer.MarkOptions.INCORRECT)
|
|
|
|
correct_answers = []
|
|
half_mark_answers = []
|
|
incorrect_answers = []
|
|
review_user_answers = []
|
|
unmarked_answers_bool = False
|
|
unmarked_user_answers = []
|
|
|
|
if review:
|
|
unmarked_user_answers = question.get_user_answers(
|
|
exam_pk=exam_pk, include_normal=False
|
|
)
|
|
elif unmarked_exam_answers_only:
|
|
unmarked_user_answers = question.get_unmarked_user_answers(exam_pk=exam_pk)
|
|
else:
|
|
unmarked_user_answers = question.get_unmarked_user_answers()
|
|
|
|
if not unmarked_exam_answers_only:
|
|
correct_answers = question.answers.filter(status=Answer.MarkOptions.CORRECT)
|
|
half_mark_answers = question.answers.filter(status=Answer.MarkOptions.HALF_MARK)
|
|
incorrect_answers = question.answers.filter(status=Answer.MarkOptions.INCORRECT)
|
|
|
|
if review:
|
|
for ans in unmarked_user_answers:
|
|
# duplicated from user answer model....
|
|
marked_ans = question.answers.filter(answer_compare__iexact=ans).first()
|
|
mark = "unmarked"
|
|
if marked_ans is not None:
|
|
if marked_ans.status == Answer.MarkOptions.CORRECT:
|
|
mark = "correct"
|
|
elif marked_ans.status == Answer.MarkOptions.HALF_MARK:
|
|
mark = "half-correct"
|
|
elif marked_ans.status == Answer.MarkOptions.INCORRECT:
|
|
mark = "incorrect"
|
|
if mark == "unmarked":
|
|
unmarked_answers_bool = True
|
|
review_user_answers.append((ans, mark))
|
|
|
|
return render(
|
|
request,
|
|
"anatomy/mark.html",
|
|
{
|
|
"exam": exam,
|
|
"form": form,
|
|
"review": review,
|
|
"question": question,
|
|
"question_number": n,
|
|
"question_details": question_details,
|
|
"unmarked_answers_bool": unmarked_answers_bool,
|
|
"user_answers": unmarked_user_answers,
|
|
"review_user_answers": review_user_answers,
|
|
"correct_answers": correct_answers,
|
|
"half_mark_answers": half_mark_answers,
|
|
"incorrect_answers": incorrect_answers,
|
|
"unmarked_exam_answers_only": unmarked_exam_answers_only,
|
|
},
|
|
)
|
|
|
|
@login_required
|
|
def exam_scores_refresh(request, pk):
|
|
exam = get_object_or_404(Exam, pk=pk)
|
|
|
|
if not exam.exam_mode:
|
|
raise Http404("Packet not in exam mode")
|
|
|
|
questions = exam.exam_questions.all()
|
|
|
|
cids = (
|
|
CidUserAnswer.objects.filter(question__in=questions, exam__id=pk)
|
|
)
|
|
|
|
# Force a score update
|
|
for c in cids:
|
|
c.get_answer_score(cached=False)
|
|
|
|
return render(
|
|
request,
|
|
"anatomy/base.html",
|
|
{
|
|
"simple_content": "Answer scores updated",
|
|
},
|
|
)
|
|
|
|
#@login_required
|
|
#def exam_scores_cid(request, pk):
|
|
# exam = get_object_or_404(Exam, pk=pk)
|
|
#
|
|
# if not exam.exam_mode:
|
|
# raise Http404("Packet not in exam mode")
|
|
#
|
|
# questions = exam.exam_questions.all()
|
|
#
|
|
# cids = (
|
|
# CidUserAnswer.objects.filter(question__in=questions, exam__id=pk)
|
|
# .order_by("cid")
|
|
# .values_list("cid", flat=True)
|
|
# .distinct()
|
|
# )
|
|
#
|
|
# user_answers_and_marks = defaultdict(list)
|
|
# user_answers_marks = defaultdict(list)
|
|
# user_answers = defaultdict(list)
|
|
# user_names = {}
|
|
#
|
|
# by_question = defaultdict(list)
|
|
# unmarked = set()
|
|
#
|
|
# # Loop through all candidates
|
|
# for cid in cids:
|
|
# # Convoluted (probably...)
|
|
# user_names[cid] = cid
|
|
# for q in questions:
|
|
# # Get user answer
|
|
# s = q.cid_user_answers.filter(cid=cid, exam__id=pk).first()
|
|
# if not s:
|
|
# # skip if no answer
|
|
# user_answers_marks[cid].append(0)
|
|
# user_answers[cid].append("")
|
|
# by_question[q].append(("", 0))
|
|
# continue
|
|
#
|
|
# ans = s.answer
|
|
# answer_score = s.get_answer_score()
|
|
# if answer_score == "unmarked":
|
|
# index = exam.get_question_index(q)
|
|
# unmarked.add(index)
|
|
# user_answers[cid].append(ans)
|
|
# user_answers_marks[cid].append(answer_score)
|
|
# user_answers_and_marks[cid].append((ans, answer_score))
|
|
#
|
|
# by_question[q].append((ans, answer_score))
|
|
#
|
|
# user_scores = {}
|
|
# for user in user_answers_marks:
|
|
# user_scores[user] = sum(
|
|
# [i for i in user_answers_marks[user] if i != "unmarked"]
|
|
# )
|
|
#
|
|
# user_scores_list = list(user_scores.values())
|
|
#
|
|
# if len(user_scores_list) < 1:
|
|
# mean = 0
|
|
# median = 0
|
|
# mode = 0
|
|
# fig_html = ""
|
|
# else:
|
|
# mean = statistics.mean(user_scores_list)
|
|
# median = statistics.median(user_scores_list)
|
|
# try:
|
|
# mode = statistics.mode(user_scores_list)
|
|
# except statistics.StatisticsError:
|
|
# mode = "No unique mode"
|
|
#
|
|
# df = user_scores_list
|
|
# fig = px.histogram(
|
|
# df,
|
|
# x=0,
|
|
# title="{}: distribution of scores".format(exam),
|
|
# labels={"0": "Score"},
|
|
# height=400,
|
|
# width=600,
|
|
# )
|
|
# fig_html = fig.to_html()
|
|
#
|
|
# max_score = len(questions) * 2
|
|
#
|
|
# exam.stats_mean = mean
|
|
# exam.stats_median = median
|
|
# exam.stats_mode = mode
|
|
#
|
|
# exam.stats_candidates = len(user_scores_list)
|
|
# exam.stats_max_possible = max_score
|
|
#
|
|
# exam.stats_min = min(user_scores_list)
|
|
# exam.stats_max = max(user_scores_list)
|
|
#
|
|
# exam.stats_graph = fig_html
|
|
# exam.save()
|
|
#
|
|
# return render(
|
|
# request,
|
|
# "anatomy/exam_scores.html",
|
|
# {
|
|
# "cids": cids,
|
|
# "exam": exam,
|
|
# "unmarked": unmarked,
|
|
# "questions": questions,
|
|
# "by_question": by_question,
|
|
# "user_answers": dict(user_answers),
|
|
# "user_answers_marks": dict(user_answers_marks),
|
|
# "user_scores": user_scores,
|
|
# "user_scores_list": user_scores_list,
|
|
# "user_names": user_names,
|
|
# "user_answers_and_marks": user_answers_and_marks,
|
|
# "max_score": max_score,
|
|
# "mean": mean,
|
|
# "median": median,
|
|
# "mode": mode,
|
|
# "plot": fig_html,
|
|
# },
|
|
# )
|
|
|
|
|
|
def exam_scores_cid_user(request, pk, sk, passcode):
|
|
exam = get_object_or_404(Exam, pk=pk)
|
|
|
|
if not exam.exam_mode:
|
|
raise Http404("Packet not in exam mode")
|
|
|
|
cid = sk
|
|
if not exam.check_cid_user(cid, passcode):
|
|
raise Http404("Error accessing exam")
|
|
|
|
questions = exam.exam_questions.all()
|
|
|
|
answers_and_marks = []
|
|
answers_marks = []
|
|
answers = []
|
|
|
|
view_all_results = False
|
|
if request.user.groups.filter(name="view_all_results").exists():
|
|
view_all_results = True
|
|
|
|
for q in questions:
|
|
# Get user answer
|
|
user_answer = q.cid_user_answers.filter(cid=cid, exam__id=pk).first()
|
|
if not user_answer:
|
|
# skip if no answer
|
|
answers_marks.append(0)
|
|
answers.append("")
|
|
answer_score = 0
|
|
ans = "Not answered"
|
|
else:
|
|
ans = user_answer.answer
|
|
|
|
answer_score = user_answer.get_answer_score()
|
|
|
|
correct_answer = q.get_primary_answer()
|
|
|
|
if not exam.publish_results and not view_all_results:
|
|
correct_answer = "*****"
|
|
answer_score = 0
|
|
answers.append(ans)
|
|
answers_marks.append(answer_score)
|
|
answers_and_marks.append((ans, answer_score, correct_answer))
|
|
|
|
if "unmarked" in answers_marks:
|
|
answered = [i for i in answers_marks if type(i) == int]
|
|
total_score = sum(answered)
|
|
unmarked_number = len(answers_marks) - len(answered)
|
|
total_score = "{} ({} unmarked)".format(total_score, unmarked_number)
|
|
else:
|
|
total_score = sum(answers_marks)
|
|
|
|
max_score = len(questions) * 2
|
|
|
|
return render(
|
|
request,
|
|
"anatomy/exam_scores_user.html",
|
|
{
|
|
"exam": exam,
|
|
"cid": cid,
|
|
"passcode": passcode,
|
|
"questions": questions,
|
|
"answers": answers,
|
|
"answers_marks": answers_marks,
|
|
"total_score": total_score,
|
|
"max_score": max_score,
|
|
"answers_and_marks": answers_and_marks,
|
|
},
|
|
)
|
|
|
|
|
|
# @login_required
|
|
# def exam_scores(request, pk):
|
|
# exam = get_object_or_404(Exam, pk=pk)
|
|
|
|
# questions = exam.exam_questions.all()
|
|
|
|
# users = (CidUserAnswer.objects.filter(
|
|
# question__in=questions).values_list("user").distinct())
|
|
|
|
# user_answers_and_marks = defaultdict(list)
|
|
# user_answers_marks = defaultdict(list)
|
|
# user_answers = defaultdict(list)
|
|
# user_names = {}
|
|
|
|
# by_question = defaultdict(list)
|
|
|
|
# for u in users:
|
|
## Convoluted (probably...)
|
|
# user_names[u] = User.objects.filter(pk=u[0]).first().get_username()
|
|
# for q in questions:
|
|
# user_answer = q.user_answers.filter(user__in=u).first()
|
|
# if not user_answer:
|
|
# user_answers_marks[u].append(0)
|
|
# user_answers[u].append("")
|
|
# continue
|
|
|
|
# ans = user_answer.answer
|
|
# answer_score = user_answer.get_answer_score()
|
|
# user_answers[u].append(ans)
|
|
# user_answers_marks[u].append(answer_score)
|
|
# user_answers_and_marks[u].append((ans, answer_score))
|
|
|
|
# by_question[q].append(ans)
|
|
|
|
# user_scores = {}
|
|
# for user in user_answers_marks:
|
|
# user_scores[user] = sum(user_answers_marks[user])
|
|
|
|
# total = len(questions)
|
|
|
|
# return render(
|
|
# request,
|
|
# "anatomy/exam_scores.html",
|
|
# {
|
|
# "exam": exam,
|
|
# "questions": questions,
|
|
# "by_question": by_question,
|
|
# "user_answers": dict(user_answers),
|
|
# "user_answers_marks": dict(user_answers_marks),
|
|
# "user_scores": user_scores,
|
|
# "user_names": user_names,
|
|
# "user_answers_and_marks": user_answers_and_marks,
|
|
# },
|
|
# )
|
|
|
|
# def cid_scores(request, pk):
|
|
# #exam = get_object_or_404(Exam, pk=pk)
|
|
#
|
|
# # TODO:Need some kind of test for cid
|
|
# cid = pk
|
|
#
|
|
# #questions = exam.exam_questions.all()
|
|
# answers = CidUserAnswer.objects.filter(
|
|
# cid=cid)
|
|
#
|
|
#
|
|
# if not answers:
|
|
# raise Http404("cid not found")
|
|
#
|
|
# exam_ids = answers.values_list("exam").distinct()
|
|
#
|
|
# exams = Exam.objects.filter(id__in=exam_ids)
|
|
#
|
|
#
|
|
# return render(
|
|
# request,
|
|
# "anatomy/cid_scores.html",
|
|
# {
|
|
# "exams": exams,
|
|
# "cid": cid,
|
|
# },
|
|
# )
|
|
|
|
|
|
class AnatomyQuestionCreateBase(RevisionMixin, LoginRequiredMixin, CreateView):
|
|
model = AnatomyQuestion
|
|
form_class = AnatomyQuestionForm
|
|
|
|
def get_form_kwargs(self):
|
|
kwargs = super(AnatomyQuestionCreateBase, self).get_form_kwargs()
|
|
kwargs.update({"user": self.request.user})
|
|
return kwargs
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super(AnatomyQuestionCreateBase, self).get_context_data(**kwargs)
|
|
if self.request.POST:
|
|
context["answer_formset"] = AnswerFormSet(
|
|
self.request.POST, self.request.FILES
|
|
)
|
|
else:
|
|
context["answer_formset"] = AnswerFormSet()
|
|
return context
|
|
|
|
def form_valid(self, form):
|
|
|
|
self.object = form.save(commit=False)
|
|
self.object.save()
|
|
|
|
form.instance.author.add(self.request.user.id)
|
|
|
|
context = self.get_context_data(form=form)
|
|
formset = context["answer_formset"]
|
|
|
|
if formset.is_valid():
|
|
response = super().form_valid(form)
|
|
formset.instance = self.object
|
|
formset.save()
|
|
# If the normal submit button is pressed we save as normal
|
|
if "submit" in self.request.POST:
|
|
return response
|
|
# else we redirect to the clone url
|
|
else:
|
|
return redirect("anatomy:question_clone", pk=self.object.pk)
|
|
|
|
else:
|
|
return super().form_invalid(form)
|
|
|
|
|
|
class AnatomyQuestionCreate(AnatomyQuestionCreateBase):
|
|
|
|
# initial = {'laterality': AnatomyQuestion.NONE}
|
|
|
|
def get_initial(self):
|
|
if "pk" in self.kwargs:
|
|
initial = super().get_initial()
|
|
exam = get_object_or_404(Exam, pk=self.kwargs["pk"])
|
|
|
|
initial["exams"] = [exam.id]
|
|
|
|
return initial
|
|
|
|
|
|
# # There has to be a better way...
|
|
# try:
|
|
# s = (i.pk for i in self.request.user.AnatomyQuestion_default.site.all())
|
|
# self.initial.update({'site': s})
|
|
# except AttributeError:
|
|
# pass
|
|
# return self.initial
|
|
#
|
|
# fields = '__all__'
|
|
# #fields = [ 'condition' ]
|
|
# #initial = {'date_of_death': '05/01/2018'}
|
|
# exclude = [ 'created_date', 'published_date' ]
|
|
|
|
# self.object = form.save(commit=False)
|
|
# self.object.save()
|
|
|
|
# form.instance.author.add(self.request.user.id)
|
|
# return super().form_valid(form)
|
|
|
|
|
|
# class AnatomyQuestionUpdate(LoginRequiredMixin, AuthorOrCheckerRequiredMixin,
|
|
class AnatomyQuestionUpdate(RevisionMixin, AuthorOrCheckerRequiredMixin, UpdateView):
|
|
model = AnatomyQuestion
|
|
form_class = AnatomyQuestionForm
|
|
|
|
def get_form_kwargs(self):
|
|
kwargs = super(AnatomyQuestionUpdate, self).get_form_kwargs()
|
|
kwargs.update({"user": self.request.user})
|
|
return kwargs
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super(AnatomyQuestionUpdate, self).get_context_data(**kwargs)
|
|
if self.request.POST:
|
|
context["answer_formset"] = AnswerUpdateFormSet(
|
|
self.request.POST, self.request.FILES, instance=self.object
|
|
)
|
|
context["answer_formset"].full_clean()
|
|
else:
|
|
context["answer_formset"] = AnswerUpdateFormSet(instance=self.object)
|
|
return context
|
|
|
|
def form_valid(self, form):
|
|
|
|
# save exam orders (there must be a better way to do this)
|
|
exam_orders = {}
|
|
for exam in self.object.exams.all():
|
|
exam_orders[exam] = list(exam.exam_questions.all())
|
|
print(exam_orders[exam])
|
|
|
|
self.object = form.save(commit=False)
|
|
self.object.save()
|
|
|
|
form.instance.author.add(self.request.user.id)
|
|
|
|
context = self.get_context_data(form=form)
|
|
formset = context["answer_formset"]
|
|
# logger.debug(formset.is_valid())
|
|
if formset.is_valid():
|
|
response = super().form_valid(form)
|
|
formset.instance = self.object
|
|
formset.save()
|
|
|
|
# restore exam orders
|
|
for exam in self.object.exams.all():
|
|
if exam in exam_orders and self.object in exam_orders[exam]:
|
|
print(exam_orders[exam])
|
|
exam.exam_questions.set(exam_orders[exam])
|
|
exam.save()
|
|
|
|
return response
|
|
else:
|
|
return super().form_invalid(form)
|
|
|
|
|
|
class QuestionClone(AnatomyQuestionCreateBase):
|
|
"""Clones a existing question"""
|
|
|
|
def get_initial(self):
|
|
# print(self.request)
|
|
old_object = get_object_or_404(AnatomyQuestion, pk=self.kwargs["pk"])
|
|
initial_data = model_to_dict(old_object, exclude=["id"])
|
|
|
|
# We don't want to clone the exam details
|
|
# exams = old_object.exams.all().values_list("id", flat=True)
|
|
|
|
# initial_data["exams"] = list(exams)
|
|
|
|
return initial_data
|
|
|
|
|
|
@login_required
|
|
def create_body_part(request):
|
|
form = BodyPartForm(request.POST or None)
|
|
if form.is_valid():
|
|
instance = form.save()
|
|
return HttpResponse(
|
|
'<script>opener.closePopup(window, "%s", "%s", "#id_body_part");</script>'
|
|
% (instance.pk, instance)
|
|
)
|
|
return render(
|
|
request, "anatomy/create_simple.html", {"form": form, "name": "BodyPart"}
|
|
)
|
|
|
|
|
|
@csrf_exempt
|
|
def get_body_part_id(request):
|
|
if request.is_ajax():
|
|
body_part_name = request.GET["body_part_name"]
|
|
body_part_id = BodyPart.objects.get(name=body_part_name).id
|
|
data = {
|
|
"body_part_id": body_part_id,
|
|
}
|
|
return HttpResponse(json.dumps(data), content_type="application/json")
|
|
return HttpResponse("/")
|
|
|
|
|
|
@login_required
|
|
def create_examination(request):
|
|
form = ExaminationForm(request.POST or None)
|
|
if form.is_valid():
|
|
instance = form.save()
|
|
return HttpResponse(
|
|
'<script>opener.closePopup(window, "%s", "%s", "#id_examination");</script>'
|
|
% (instance.pk, instance)
|
|
)
|
|
return render(
|
|
request, "anatomy/create_simple.html", {"form": form, "name": "Examination"}
|
|
)
|
|
|
|
|
|
@csrf_exempt
|
|
def get_examination_id(request):
|
|
if request.is_ajax():
|
|
examination_name = request.GET["examination_name"]
|
|
examination_id = Examination.objects.get(name=examination_name).id
|
|
data = {
|
|
"examination_id": examination_id,
|
|
}
|
|
return HttpResponse(json.dumps(data), content_type="application/json")
|
|
return HttpResponse("/")
|
|
|
|
|
|
@login_required
|
|
def create_structure(request):
|
|
form = StructureForm(request.POST or None)
|
|
if form.is_valid():
|
|
instance = form.save()
|
|
return HttpResponse(
|
|
'<script>opener.closePopup(window, "%s", "%s", "#id_structure");</script>'
|
|
% (instance.pk, instance)
|
|
)
|
|
return render(
|
|
request, "anatomy/create_simple.html", {"form": form, "name": "Structure"}
|
|
)
|
|
|
|
|
|
@csrf_exempt
|
|
def get_structure_id(request):
|
|
if request.is_ajax():
|
|
structure_name = request.GET["structure_name"]
|
|
structure_id = Structure.objects.get(name=structure_name).id
|
|
data = {
|
|
"structure_id": structure_id,
|
|
}
|
|
return HttpResponse(json.dumps(data), content_type="application/json")
|
|
return HttpResponse("/")
|
|
|
|
|
|
class AnatomyQuestionView(LoginRequiredMixin, SingleTableMixin, FilterView):
|
|
model = AnatomyQuestion
|
|
table_class = AnatomyQuestionTable
|
|
template_name = "anatomy/view.html"
|
|
|
|
filterset_class = AnatomyQuestionFilter
|
|
|
|
|
|
@user_is_author_or_anatomy_checker
|
|
def question_save_annotation(request, pk):
|
|
if request.is_ajax() and request.method == "POST":
|
|
question = get_object_or_404(AnatomyQuestion, pk=pk)
|
|
|
|
question.image_annotations = request.POST.get("annotation")
|
|
print(question.image_annotations)
|
|
|
|
question.save()
|
|
data = {"status": "success"}
|
|
return JsonResponse(data, status=200)
|
|
else:
|
|
data = {"status": "error"}
|
|
return JsonResponse(data, status=400)
|
|
|
|
|
|
AnatomyExamViews = ExamViews(
|
|
Exam, AnatomyQuestion, CidUserAnswer, "anatomy", "anatomy", loadJsonAnswer
|
|
)
|
|
|
|
|
|
class UserAnswerView(LoginRequiredMixin, DetailView):
|
|
model = CidUserAnswer
|
|
|
|
|
|
class UserAnswerTableView(LoginRequiredMixin, SingleTableMixin, FilterView):
|
|
model = CidUserAnswer
|
|
table_class = AnatomyUserAnswerTable
|
|
template_name = "anatomy/user_answer_question_view.html"
|
|
|
|
filterset_class = AnatomyUserAnswerFilter
|
|
|
|
|
|
class UserAnswerDelete(SuperuserRequiredMixin, DeleteView):
|
|
model = CidUserAnswer
|
|
template_name = "user_answer_delete.html"
|
|
success_url = reverse_lazy("anatomy:user_answer_table_view")
|
|
|
|
|
|
class QuestionDelete(AuthorOrCheckerRequiredMixin, DeleteView):
|
|
model = AnatomyQuestion
|
|
success_url = reverse_lazy("anatomy:question_list")
|
|
|
|
|
|
class ExamCreate(RevisionMixin, LoginRequiredMixin, CreateView):
|
|
model = Exam
|
|
form_class = ExamForm
|
|
|
|
def form_valid(self, form):
|
|
self.object = form.save(commit=False)
|
|
self.object.save()
|
|
|
|
form.instance.author.add(self.request.user.id)
|
|
return super().form_valid(form)
|
|
|
|
|
|
class ExamUpdate(
|
|
RevisionMixin, LoginRequiredMixin, AuthorOrCheckerRequiredMixin, UpdateView
|
|
):
|
|
model = Exam
|
|
form_class = ExamForm
|
|
|
|
def form_valid(self, form):
|
|
self.object = form.save(commit=False)
|
|
self.object.save()
|
|
|
|
form.instance.author.add(self.request.user.id)
|
|
return super().form_valid(form)
|
|
|
|
|
|
class ExamViewSet(RevisionMixin, viewsets.ModelViewSet):
|
|
# queryset = Exam.objects.all().order_by('name')
|
|
serializer_class = ExamSerializer
|
|
permission_classes = [permissions.IsAuthenticated]
|
|
|
|
def get_queryset(self):
|
|
"""
|
|
This view should return a list exams available to a user.
|
|
"""
|
|
user = self.request.user
|
|
if user.groups.filter(name="anatomy_checker").exists():
|
|
return Exam.objects.all()
|
|
|
|
return Exam.objects.filter(author__id=user.id)
|
|
|
|
|
|
class ExamDelete(RevisionMixin, AuthorOrCheckerRequiredMixin, DeleteView):
|
|
model = Exam
|
|
template_name = "exam_confirm_delete.html"
|
|
success_url = reverse_lazy("anatomy:index")
|
|
|
|
|
|
GenericViews = GenericViewBase("anatomy", AnatomyQuestion, CidUserAnswer, Exam)
|
|
|
|
|
|
class ExamClone(ExamCloneMixin, ExamCreate):
|
|
"""Clone exam view"""
|
|
|
|
|
|
class StructureAutocomplete(autocomplete.Select2QuerySetView):
|
|
def get_queryset(self):
|
|
# Don't forget to filter out results depending on the visitor !
|
|
if not self.request.user.is_authenticated:
|
|
return Structure.objects.none()
|
|
|
|
qs = Structure.objects.all()
|
|
|
|
if self.q:
|
|
# This raises a fielderror which breaks creating a new item if not caught
|
|
try:
|
|
qs = qs.filter(name__istartswith=self.q)
|
|
except FieldError:
|
|
return Structure.objects.none()
|
|
|
|
return qs
|