forms.py

from django import forms
from django.db import transaction
from django.utils.translation import gettext_lazy as _

from core import models as core_models, forms as core_forms
from core.model_utils import JanewayBleachFormField
from plugins.typesetting import models
from utils.forms import HTMLDateInput


class TypesettingAssignmentForm(
    forms.ModelForm,
    core_forms.ConfirmableIfErrorsForm
):

    # Confirmable form modification
    QUESTION = _('Are you sure you want to create a typesetting assignment?')

    def __init__(self, *args, **kwargs):
        typesetters = kwargs.pop('typesetters')
        files = kwargs.pop('files')
        galleys = kwargs.pop('galleys', ())
        initial_galleys_to_correct = kwargs.pop('initial_galleys_to_correct', ())
        self.rounds = kwargs.pop('rounds')
        super().__init__(*args, **kwargs)

        self.fields['typesetter'].queryset = typesetters
        self.fields['files_to_typeset'].queryset = files
        self.fields['galleys_to_correct'] = forms.MultipleChoiceField(
            widget=forms.CheckboxSelectMultiple(),
            required=False,
            choices=[(g.pk, g.detail()) for g in galleys],
            initial=initial_galleys_to_correct,
        )

    class Meta:
        model = models.TypesettingAssignment
        fields = (
            'typesetter',
            'due',
            'task',
            'files_to_typeset',
            'display_proof_comments',
        )

        widgets = {
            'due': HTMLDateInput(),
        }

    def save(self, commit=True):
        assignment = super().save(commit=False)
        assignment.round = self.rounds[0]

        if commit:
            with transaction.atomic():
                assignment.save()

                for file in assignment.files_to_typeset.all():
                    assignment.files_to_typeset.remove(file)
                for file in self.cleaned_data.get('files_to_typeset', ()):
                    assignment.files_to_typeset.add(file)

                galleys_to_correct = self.cleaned_data.get('galleys_to_correct', ())
                for correction in assignment.corrections.all():
                    if correction.galley.pk not in galleys_to_correct:
                        correction.delete()
                for galley_id in galleys_to_correct:
                    galley = core_models.Galley.objects.get(pk=galley_id)
                    assignment.corrections.get_or_create(
                        task=assignment,
                        galley=galley,
                        label=galley.label,
                    )

        return assignment

    def check_for_potential_errors(self):
        # Confirmable form modification
        potential_errors = []

        typesetter = self.cleaned_data.get('typesetter', None)
        message = self.check_for_inactive_account(typesetter)
        if message:
            potential_errors.append(message)

        files_to_typeset = self.cleaned_data.get('files_to_typeset', ())
        if not files_to_typeset:
            message = "No files were selected for typesetting. The typesetter " \
                      "may not have access to the right files."
            potential_errors.append(message)

        galleys_to_correct = self.cleaned_data.get('galleys_to_correct', ())
        if not galleys_to_correct and self.rounds.first().article.galley_set.exists():
            message = "No galleys were marked for correction."
            potential_errors.append(message)

        for galley_id in galleys_to_correct:
            try:
                galley = core_models.Galley.objects.get(pk=galley_id)
                if galley.file not in files_to_typeset:
                    message = f"The galley with a label of {galley.label} " \
                              f"was selected for correction, but the typesetter " \
                              f"was not given access to the linked " \
                              f"file: {galley.file.pk} - {galley.file.original_filename}."
                    potential_errors.append(message)
            except core_models.Galley.DoesNotExist:
                pass

        return potential_errors

    def last_typesetter(self):
        if len(self.rounds) > 1:
            return self.rounds[1].typesettingassignment.typesetter
        else:
            return None


class EditTypesettingAssignmentForm(TypesettingAssignmentForm):
    QUESTION = _('Are you sure you want to save the typesetting assignment?')
    CONFIRMABLE_BUTTON_NAME = 'edit_confirmable'
    CONFIRMED_BUTTON_NAME = 'edit_confirmed'


class AssignProofreader(forms.ModelForm, core_forms.ConfirmableIfErrorsForm):

    # Confirmable form modification
    QUESTION = _('Are you sure you want to create a proofreading assignment?')

    def __init__(self, *args, **kwargs):
        self.proofreaders = kwargs.pop('proofreaders')
        self.round = kwargs.pop('round')
        self.manager = kwargs.pop('user')
        super(AssignProofreader, self).__init__(*args, **kwargs)

        self.fields['proofreader'].queryset = self.proofreaders

    class Meta:
        model = models.GalleyProofing
        fields = ('proofreader', 'task', 'due',)

        widgets = {
            'due': HTMLDateInput(),
        }

    def save(self, commit=True):
        assignment = super(AssignProofreader, self).save(commit=False)
        assignment.round = self.round
        assignment.manager = self.manager

        if commit:
            assignment.save()

        return assignment

    def check_for_potential_errors(self):
        # Confirmable form modification
        potential_errors = []

        proofreader = self.cleaned_data.get('proofreader', None)
        message = self.check_for_inactive_account(proofreader)
        if message:
            potential_errors.append(message)

        return potential_errors


def decision_choices():
    return (
        ('accept', 'Accept'),
        ('decline', 'Decline'),
    )


class TypesetterDecision(forms.Form):
    decision = forms.ChoiceField(choices=decision_choices(), required=True)
    note = JanewayBleachFormField(required=False)


class ManagerDecision(forms.ModelForm):

    class Meta:
        model = models.TypesettingAssignment
        fields = ('review_decision',)

    def save(self, commit=True):
        decision = super(ManagerDecision, self).save(commit=False)
        decision.reviewed = True
        if commit:
            decision.save()

        return decision


class SupplementaryFileChoiceForm(forms.ModelForm):
    label = forms.CharField(
        required=False,
        help_text=_("Text to show as the download link on the article page")
    )

    def __init__(self, *args, **kwargs):
        self.article = kwargs.pop('article')
        super().__init__(*args, **kwargs)
        files = core_models.File.objects.filter(
            article_id=self.article.pk,
        ).exclude(
            supplementaryfile__file__article_id = self.article.pk,
        )
        self.fields['file'].queryset = files

    class Meta:
        model = core_models.SupplementaryFile
        fields = ('file',)

    def save(self, commit=True):
        instance = super().save(commit=commit)
        if commit:
            if self.cleaned_data.get("label"):
                instance.file.label = self.cleaned_data["label"]
                instance.file.save()
            self.article.supplementary_files.add(instance)
        return instance


class EditProofingAssignment(forms.ModelForm):
    class Meta:
        model = models.GalleyProofing
        fields = ('task', 'due',)
        widgets = {
            'due': HTMLDateInput(),
        }


class ProofingForm(forms.ModelForm, core_forms.ConfirmableForm):

    # Confirmable form constants
    QUESTION = _('Are you sure you want to complete the proofreading task?')

    class Meta:
        model = models.GalleyProofing
        fields = ('notes',)
        summernote_attrs = {
            'disable_attachment': True,
            'height': '500px',
        }

    def check_for_potential_errors(self):
        # This customizes the confirmable form method
        potential_errors = []

        # Check for unproofed galleys
        galleys = core_models.Galley.objects.filter(
            article=self.instance.round.article,
        )
        unproofed_galleys = self.instance.unproofed_galleys(galleys)
        if unproofed_galleys:
            message = _('You have not proofed some galleys:')+' {}.'.format(
                        ", ".join([g.label for g in unproofed_galleys])
                    )
            potential_errors.append(message)

        # Check if a note was added
        if not self.cleaned_data.get('notes', None):
            message = 'The Notes field is empty.'
            potential_errors.append(_(message))

        # Check if new files were added
        annotated_files = self.instance.annotated_files.all()
        if annotated_files:
            last_upload = max(set(an_file.date_uploaded for an_file in annotated_files))
            last_editor_or_typesetter_action = max(filter(bool, [
                self.instance.completed,
                self.instance.assigned,
            ]))
            if last_editor_or_typesetter_action > last_upload:
                message = 'The annotated files have not been changed.'
                potential_errors.append(_(message))
        else:
            message = 'No annotated files have been uploaded.'
            potential_errors.append(_(message))

        return potential_errors


class GalleyForm(forms.ModelForm):
    file = forms.FileField()

    class Meta:
        model = core_models.Galley
        fields = (
            'label',
            'public',
        )

    def __init__(self, *args, **kwargs):
        include_file = kwargs.pop('include_file', True)
        super().__init__(*args, **kwargs)
        self.fields['label'].required = False

        if not include_file:
            self.fields.pop('file')