penracourses/rcr/views.py

from typing import Any
from django.db import models
from django.http import Http404, HttpResponseRedirect
from django.shortcuts import redirect, render
from django.urls import reverse, reverse_lazy
from django.views.generic.edit import UpdateView 
from django.views.generic.detail import DetailView
from django.shortcuts import get_object_or_404
from django.conf import settings
from django.contrib.auth.models import User
from django.contrib.auth.decorators import user_passes_test


from rcr.models import Item
from rcr.forms import AssessorAssignmentForm, ItemForm
from django.core.exceptions import PermissionDenied

# Create your views here.

def user_is_rcr(function):
    def wrap(request, *args, **kwargs):
        if (
            request.user.groups.filter(name="rcr_radiology_assessor").exists()
            or request.user.is_superuser
        ):
            return function(request, *args, **kwargs)
        else:
            raise PermissionDenied

    wrap.__doc__ = function.__doc__
    wrap.__name__ = function.__name__
    return wrap


class RCRRequiredMixin(object):
    def get_object(self, *args, **kwargs):
        obj = super().get_object(*args, **kwargs)
        if (
            self.request.user.groups.filter(name="rcr_radiology_assessor").exists()
            or self.request.user.is_superuser
        ):
            return obj
        if self.request.user not in obj.get_author_objects():
            raise PermissionDenied()  # or Http404

        return obj

@user_is_rcr
def radiology_index(request, assigned=True, user_pk: int | None = None):

    if assigned:
        items = Item.objects.filter(assigned_to=request.user).exclude(completed=True)
    elif user_pk is not None:
        items = Item.objects.filter(assigned_to__pk=user_pk).exclude(completed=True)
    else:
        items = Item.objects.all().exclude(completed=True)

    return render(
        request,
        "rcr/index.html",
        {
            "items": items,
            "completed": False
        },
    )

@user_passes_test(lambda u: u.is_superuser)
def radiology_assessor_assignment(request, assessor_pk: int):

    user = get_object_or_404(User, pk=assessor_pk)
    if request.method == "POST":
        assessor_assignment_form = AssessorAssignmentForm(request.POST)

        if assessor_assignment_form.is_valid():
            items_to_update = assessor_assignment_form.cleaned_data["items"]
            for item in items_to_update:
                item.assigned_to = user

            Item.objects.filter(pk__in=items_to_update).bulk_update(items_to_update, ["assigned_to"])

            return HttpResponseRedirect(reverse("rcr:radiology_assessors_view"))
    else:
        assessor_assignment_form = AssessorAssignmentForm()

    return render(
        request,
        "rcr/assessor_assignment_form.html",
        {
            "assessor_assignment_form": assessor_assignment_form,
            "user_to_assign": user
        },
    )

@user_is_rcr
def radiology_assigned_user(request, user_pk=int):
    return radiology_index(request, user_pk=user_pk)
    pass

@user_is_rcr
def radiology_assessors(request):
    assessors = User.objects.filter(groups__name="rcr_radiology_assessor")

    return render(
        request,
        "rcr/assessors.html",
        {
            "assessors": assessors
        },
    )

@user_is_rcr
def radiology_index_completed_by_user(request, user_pk: int):
    return radiology_index_completed(request, user_pk = user_pk)

@user_is_rcr
def radiology_index_completed(request, user_pk=None):

    assessor = None
    if user_pk is not None:
        items = Item.objects.filter(completed=True, assessed_by=user_pk).order_by("pk")
        assessor = User.objects.get(pk=user_pk)
    else:
        items = Item.objects.filter(completed=True)

    return render(
        request,
        "rcr/index.html",
        {
            "items": items,
            "completed": True,
            "assessor": assessor
        },
    )


class ItemUpdateBase(UpdateView, RCRRequiredMixin):
    def form_valid(self, form):
        self.object = form.save(commit=False)
        self.object.save()

        form.instance.assessed_by.add(self.request.user.id)
        return super().form_valid(form)

class ItemUpdateView(ItemUpdateBase, RCRRequiredMixin):
    model = Item

    form_class = ItemForm
    template_name = "rcr/item_update.html"
    #excludes = ["rcr_platform_id"]
    #fields = ["category", "level"]

class ItemUpdateNextView(ItemUpdateBase, RCRRequiredMixin):
    model = Item

    form_class = ItemForm
    template_name = "rcr/item_update.html"

    skip = 0

    def get_context_data(self, **kwargs: Any) -> dict[str, Any]:
        context = super().get_context_data(**kwargs)
        context["skip"] = self.skip

        return context

    def get(self, request, *args, **kwargs):
        try:
            if "skip" in kwargs:
                self.skip = kwargs["skip"]
            self.object = self.get_object()
        except Http404:
            # redirect here
            return redirect("rcr:radiology_index_view")
        context = self.get_context_data(object=self.object)
        return self.render_to_response(context)

    def get_object(self):
        if self.skip < 1:
            obj = Item.objects.filter(completed=False).order_by("pk").first()
        else:
            try:
                obj = Item.objects.filter(completed=False)[self.skip]
            except IndexError:
                raise Http404

        print("HELLO", obj)
        print(obj)

        if not obj:
            print("raise")
            raise Http404

        return obj
        print("test")
        return super().get_object()

    #def get

    def get_success_url(self) -> str:
        return reverse_lazy("rcr:radiology_update_next_view")


    

class ItemDetailView(DetailView, RCRRequiredMixin):
    model = Item
    #template_name = "TEMPLATE_NAME"
    #excludes = ["rcr_platform_id"]