penracourses/anatomy/views.py

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,
    ExamAuthorForm,
    ExaminationForm,
    MarkAnatomyQuestionForm,
    AnatomyQuestionForm,
    StructureForm,
    ExamForm,
)
from .models import (
    AnatomyQuestion,
    BodyPart,
    UserAnswer,
    # Examination,
    Structure,
    Exam,
    Answer,
    # HalfMarkAnswers,
    # IncorrectAnswers,
)
from generic.models import CidUser, Examination
from generic.views import AuthorRequiredMixin, ExamCloneMixin, ExamCreateBase, ExamDeleteBase, ExamUpdateBase, 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):
    if dictionary is None:
        return None
    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)




@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")

    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 = UserAnswer.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",
        },
    )


def exam_scores_cid_user(request, pk, cid, passcode):
    exam = get_object_or_404(Exam, pk=pk)

    if not exam.exam_mode:
        raise Http404("Packet not in exam mode")

    if not exam.check_cid_user(cid, passcode, request):
        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,
            "view_all_results": view_all_results,
        },
    )



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"])

        if self.request.user not in old_object.get_author_objects() and not self.request.user.is_superuser:
            raise PermissionDenied()  # or Http404

        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.accepts("application/json")():
        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.accepts("application/json")():
        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.accepts("application/json")():
        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 = "question_table_view.html"

    filterset_class = AnatomyQuestionFilter

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context["app_name"] = "anatomy"
        return context

    # def get_queryset(self):
    #    qs = super().get_queryset()

    #    qs = qs.select_related('modality', 'question_type')

    #    return qs


@user_is_author_or_anatomy_checker
def question_save_annotation(request, pk):
    if 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)


GenericExamViews = ExamViews(
    Exam, AnatomyQuestion, Answer, UserAnswer, "anatomy", "anatomy"
)


class UserAnswerView(SuperuserRequiredMixin, DetailView):
    model = UserAnswer


class UserAnswerTableView(SuperuserRequiredMixin, SingleTableMixin, FilterView):
    model = UserAnswer
    table_class = AnatomyUserAnswerTable
    template_name = "anatomy/user_answer_question_view.html"

    filterset_class = AnatomyUserAnswerFilter


class UserAnswerDelete(SuperuserRequiredMixin, DeleteView):
    model = UserAnswer
    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(ExamCreateBase):
    model = Exam
    form_class = ExamForm


class ExamUpdate(ExamUpdateBase, AuthorOrCheckerRequiredMixin):
    model = Exam
    form_class = ExamForm


class ExamDelete(AuthorOrCheckerRequiredMixin, ExamDeleteBase):
    model = Exam



#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 ExamAuthorUpdate(RevisionMixin, LoginRequiredMixin, AuthorRequiredMixin, UpdateView):
    model = Exam
    form_class = ExamAuthorForm



GenericViews = GenericViewBase("anatomy", AnatomyQuestion, UserAnswer, 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(structure__icontains=self.q)
            except FieldError:
                return Structure.objects.none()

        return qs