PyRIGS/training/views.py

import reversion

from django.urls import reverse_lazy
from django.views import generic
from django.utils import timezone
from django.db import transaction
from django.db.models import Q, Count
from django.db.utils import IntegrityError

from PyRIGS.views import is_ajax, ModalURLMixin, get_related
from training import models, forms
from users import views
from reversion.views import RevisionMixin


class ItemList(generic.ListView):
    template_name = "item_list.html"
    model = models.TrainingItem

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context["page_title"] = "Training Items"
        context["categories"] = models.TrainingCategory.objects.all()
        return context


class TraineeDetail(views.ProfileDetail):
    template_name = "trainee_detail.html"
    model = models.Trainee

    def get_queryset(self):
        return self.model.objects.prefetch_related('qualifications_obtained')

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        if self.request.user.pk == self.object.pk:
            context["page_title"] = "Your Training Record"
        else:
            context["page_title"] = f"{self.object.get_full_name()}'s Training Record"
        context["started_levels"] = self.object.started_levels()
        context["completed_levels"] = self.object.level_qualifications.all()
        context["categories"] = models.TrainingCategory.objects.all().prefetch_related('items')
        return context


class TraineeItemDetail(generic.ListView):
    model = models.TrainingItemQualification
    template_name = 'trainee_item_list.html'

    def get_queryset(self):
        return models.Trainee.objects.get(pk=self.kwargs['pk']).qualifications_obtained.search(self.request.GET.get('q')).order_by('item__category__reference_number', 'item__reference_number').select_related('item', 'trainee')

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        trainee = models.Trainee.objects.get(pk=self.kwargs['pk'])
        context["trainee"] = models.Trainee.objects.get(pk=self.kwargs['pk'])
        context["page_title"] = f"Detailed Training Record for <a href='{trainee.get_absolute_url()}'>{trainee}</a>"
        return context


class LevelDetail(generic.DetailView):
    template_name = "level_detail.html"
    model = models.TrainingLevel

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context["page_title"] = f"Training Level {self.object} {self.object.get_icon}"
        context["users_with"] = map(lambda qual: qual.trainee, models.TrainingLevelQualification.objects.filter(level=self.object))
        context["u"] = models.Trainee.objects.get(pk=self.kwargs['u']) if 'u' in self.kwargs else self.request.user
        return context


class LevelList(generic.ListView):
    model = models.TrainingLevel
    template_name = "level_list.html"

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context["page_title"] = "All Training Levels"
        return context


class TraineeList(generic.ListView):
    model = models.Trainee
    template_name = 'trainee_list.html'
    paginate_by = 25

    def get_queryset(self):
        objects = self.model.objects.search(self.request.GET.get('q'))

        if self.request.GET.get('is_supervisor', ''):
            objects = objects.filter(is_supervisor=True)

        return objects.annotate(num_qualifications=Count('qualifications_obtained', filter=Q(qualifications_obtained__depth=models.TrainingItemQualification.PASSED_OUT))
                                ).order_by('-num_qualifications').prefetch_related('level_qualifications', 'qualifications_obtained', 'qualifications_obtained__item')

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context["page_title"] = "Training Profile List"
        return context


class AddQualification(generic.CreateView, ModalURLMixin):
    template_name = "edit_training_record.html"
    model = models.TrainingItemQualification
    form_class = forms.QualificationForm

    def form_valid(self, form, *args, **kwargs):
        reversion.add_to_revision(form.cleaned_data['trainee'])
        return super().form_valid(form, *args, **kwargs)

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context["depths"] = models.TrainingItemQualification.CHOICES
        if is_ajax(self.request):
            context['override'] = "base_ajax.html"
        else:
            context['override'] = 'base_training.html'
        trainee = models.Trainee.objects.get(pk=self.kwargs['pk'])
        context['page_title'] = f"Add Qualification for {trainee}"
        get_related(context['form'], context)
        return context

    def get_success_url(self):
        return self.get_close_url('add_qualification', 'trainee_detail')

    def get_form_kwargs(self):
        kwargs = super().get_form_kwargs()
        kwargs['pk'] = self.kwargs['pk']
        return kwargs


class EditQualification(generic.UpdateView):
    template_name = 'edit_training_record.html'
    model = models.TrainingItemQualification
    form_class = forms.QualificationForm

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context["depths"] = models.TrainingItemQualification.CHOICES
        context['page_title'] = f"Edit Qualification <em>{self.object}</em> for {self.object.trainee}"
        get_related(context['form'], context)
        return context

    @transaction.atomic()
    @reversion.create_revision()
    def form_valid(self, form, *args, **kwargs):
        reversion.add_to_revision(form.cleaned_data['trainee'])
        return super().form_valid(form, *args, **kwargs)


class AddLevelRequirement(generic.CreateView, ModalURLMixin):
    template_name = "add_level_requirement.html"
    model = models.TrainingLevelRequirement
    form_class = forms.RequirementForm

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        level = models.TrainingLevel.objects.get(pk=self.kwargs['pk'])
        context["page_title"] = f"Add Requirements to Training Level {level}"
        get_related(context['form'], context)
        return context

    def get_form_kwargs(self):
        kwargs = super().get_form_kwargs()
        kwargs['pk'] = self.kwargs['pk']
        return kwargs

    def get_success_url(self):
        return self.get_close_url('level_detail', 'level_detail')

    @transaction.atomic()
    @reversion.create_revision()
    def form_valid(self, form, *args, **kwargs):
        reversion.add_to_revision(form.cleaned_data['level'])
        return super().form_valid(form, *args, **kwargs)


class RemoveRequirement(generic.DeleteView):
    model = models.TrainingLevelRequirement
    template_name = 'traininglevelrequirement_confirm_delete.html'

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context["page_title"] = f"Delete Requirement '{self.object}' from Training Level {self.object.level}?"
        return context

    def get_success_url(self):
        return self.request.POST.get('next')

    @transaction.atomic()
    @reversion.create_revision()
    def delete(self, *args, **kwargs):
        reversion.add_to_revision(self.get_object().level)
        return super().delete(*args, **kwargs)


class ConfirmLevel(generic.RedirectView):
    @transaction.atomic()
    @reversion.create_revision()
    def get_redirect_url(self, *args, **kwargs):
        trainee = models.Trainee.objects.get(pk=kwargs['pk'])
        level_qualification, created = models.TrainingLevelQualification.objects.get_or_create(trainee=trainee, level=models.TrainingLevel.objects.get(pk=kwargs['level_pk']))

        if created:
            user = self.request.user
            reversion.set_user(user)
            level_qualification.confirmed_by = self.request.user
            level_qualification.confirmed_on = timezone.now()
            level_qualification.save()
            reversion.add_to_revision(trainee)

        return reverse_lazy('trainee_detail', kwargs={'pk': kwargs['pk']})


class SessionLog(generic.FormView):
    template_name = 'session_log_form.html'
    form_class = forms.SessionLogForm
    success_url = reverse_lazy('trainee_list')

    def form_valid(self, form, *args, **kwargs):
        for trainee in form.cleaned_data.get('trainees', []):
            for depth in models.TrainingItemQualification.CHOICES:
                for item in form.cleaned_data.get(f'items_{depth[0]}', []):
                    try:
                        with transaction.atomic():
                            models.TrainingItemQualification.objects.create(trainee=trainee, item=item, supervisor=form.cleaned_data.get('supervisor'), depth=depth[0], notes=form.cleaned_data.get('notes'), date=form.cleaned_data.get('date'))
                            reversion.add_to_revision(trainee)
                    except IntegrityError:
                        pass  # There was an attempt to create a duplicate qualification, ignore it
        return super().form_valid(form, *args, **kwargs)

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context["depths"] = models.TrainingItemQualification.CHOICES
        context["page_title"] = "Log Training Session"
        get_related(context['form'], context)
        return context


class ItemQualifications(generic.ListView):
    template_name = "item_qualification_list.html"
    model = models.TrainingItemQualification
    paginate_by = 40

    def get_queryset(self):
        return models.TrainingItemQualification.objects.filter(item=self.kwargs['pk']).order_by('-depth').select_related('trainee')

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context["page_title"] = f"People Qualified In {self.object_list[0].item}"
        return context