models.py

from datetime import date, timedelta

from django.db import models
from django.utils import timezone

from core.model_utils import JanewayBleachField
from plugins.typesetting import plugin_settings
from utils import models as utils_models
from utils import notify_helpers
from events import logic as events_logic
from submission import models as submission_models


def review_choices():
    return (
        ('accept', 'Accept'),
        ('corrections', 'Corrections Required'),
        ('proofing', 'Proofing Required'),
    )


class TypesettingClaim(models.Model):
    editor = models.ForeignKey(
        'core.Account',
        on_delete=models.CASCADE,
    )
    article = models.OneToOneField(
        'submission.Article',
        on_delete=models.CASCADE,
    )
    claimed = models.DateTimeField(default=timezone.now)

    class Meta:
        unique_together = ('editor', 'article',)


class TypesettingRound(models.Model):
    article = models.ForeignKey(
        'submission.Article',
        on_delete=models.CASCADE,
    )
    round_number = models.PositiveIntegerField(default=1)
    date_created = models.DateTimeField(auto_now_add=True)

    class Meta:
        ordering = ('-round_number', 'date_created')
        unique_together = ('round_number', 'article',)

    def __str__(self):
        return str(self.round_number)

    @property
    def has_completed_proofing(self):
        return GalleyProofing.objects.filter(
            round=self,
            accepted__isnull=False,
            completed__isnull=False,
        )

    @property
    def has_open_tasks(self):
        if hasattr(self, 'typesettingassignment'):
            if not self.typesettingassignment.done:
                return True

        if self.galleyproofing_set.filter(completed__isnull=True).exists():
            return True

        return False

    def close(self, user=None):
        """ Method that closes a round by cancelling any open tasks """
        if hasattr(self, 'typesettingassignment'):
            if self.typesettingassignment.is_active:
                self.typesettingassignment.cancel(user=user)

        for proofing in self.galleyproofing_set.filter(
            completed__isnull=True,
        ):
            proofing.cancel(user=user)


class ActiveTypesettingAssignmentManager(models.Manager):
    def get_queryset(self):
        return super(ActiveTypesettingAssignmentManager, self).get_queryset().exclude(
            round__article__stage=submission_models.STAGE_ARCHIVED,
        )


class TypesettingAssignment(models.Model):
    round = models.OneToOneField(
        TypesettingRound,
        on_delete=models.CASCADE,
    )
    manager = models.ForeignKey(
        'core.Account',
        null=True,
        blank=True,
        on_delete=models.SET_NULL,
        related_name='manager',
    )
    typesetter = models.ForeignKey(
        'core.Account',
        null=True,
        on_delete=models.SET_NULL,
        related_name='typesetter',
    )

    assigned = models.DateTimeField(default=timezone.now)
    notified = models.BooleanField(default=False)
    accepted = models.DateTimeField(blank=True, null=True)
    due = models.DateField(null=True)
    completed = models.DateTimeField(blank=True, null=True)
    cancelled = models.DateTimeField(blank=True, null=True)
    reviewed = models.BooleanField(default=False)
    display_proof_comments = models.BooleanField(
        default=True,
        help_text="Allow the typesetter to see the proofreading comments",
    )
    review_decision = models.CharField(
        choices=review_choices(),
        max_length=21,
        blank=True,
    )

    task = JanewayBleachField(
        blank=True,
        verbose_name='Typesetting Task',
        help_text='The task description if not explained in the typesetting guidelines.',
    )
    files_to_typeset = models.ManyToManyField(
        'core.File',
        related_name='files_to_typeset',
        blank=True,
    )
    galleys_created = models.ManyToManyField(
        'core.Galley',
        blank=True,
    )
    typesetter_note = JanewayBleachField(
        blank=True,
        verbose_name='Note to Editor',
    )

    objects = models.Manager()
    active_objects = ActiveTypesettingAssignmentManager()

    @property
    def time_to_due(self):
        if not self.due:
            return ''
        due = self.due - timezone.now().date()
        if due == timedelta(0):
            return 'Due Today'
        elif due < timedelta(0):
            return 'Overdue'

        return '{} days'.format(due.days)

    @property
    def is_active(self):
        return self.assigned and not self.completed

    @property
    def status(self):
        if self.cancelled:
            return "cancelled"
        if self.assigned and not self.accepted and not self.completed:
            return "assigned"
        elif self.assigned and self.accepted and not self.completed:
            return "accepted"
        elif self.declined:
            return "declined"
        elif self.done and not self.reviewed:
            return "completed"
        elif self.done and self.reviewed:
            return self.get_review_decision_display()
        else:
            return "unknown"

    @property
    def done(self):
        return self.completed and self.accepted

    @property
    def declined(self):
        return self.completed and not self.accepted

    @property
    def is_overdue(self):
        return self.due and self.due < date.today()

    def reopen(self, user=None):
        self.completed = self.accepted = None
        self.notified = False
        utils_models.LogEntry.add_entry(
            types="Typesetting reopened",
            description="The typesetting assignment {self.pk} has been "
            "re-opened by user {user}".format(self=self, user=user),
            level="INFO",
            actor=user,
            target=self.round.article,
        )
        self.save()

    def delete(self, user=None):
        utils_models.LogEntry.add_entry(
            types="Typesetting deleted",
            description="The typesetting assignment {self.pk} has been "
            "deleted by user {user}".format(self=self, user=user),
            level="INFO",
            actor=user,
            target=self.round.article,
        )
        super().delete()

    def cancel(self, user=None):
        utils_models.LogEntry.add_entry(
            types="Typesetting Task cancelled",
            description="The typesetting assignment {self.pk} has been "
            "cancelled by user {user}".format(self=self, user=user),
            level="INFO",
            actor=user,
            target=self.round.article,
        )
        self.cancelled = timezone.now()
        self.save()

    def complete(self, note='', user=None):
        utils_models.LogEntry.add_entry(
            types="Typesetting Task Completed",
            description="The typesetting assignment {self.pk} has been "
                        "completed by user {user}".format(self=self, user=user),
            level="INFO",
            actor=user,
            target=self.round.article,
        )

        self.typesetter_note = note

        if not self.accepted:
            self.accepted = timezone.now()

        self.completed = timezone.now()
        self.save()

    FRIENDLY_STATUSES = {
        "assigned": "Awaiting response from the typesetter.",
        "accepted": "Typesetter has accepted task, awaiting completion.",
        "declined": "Typesetter has declined this task.",
        "completed": "The typesetter has completed their task. "
                     "You should review the uploaded galley files.",
        "cancelled": "The manager has cancelled this typesetting task",
        "closed": "Task closed",
        "unknown": "Task status unknown",
        "Corrections Required": "This article requires corrections.",
        "Proofing Required": "This article requires proofing.",
        "Accept": "Typesetting for this article has been completed. However,"
            " if you want to make further changes, you can still assign"
            " proofreaders or start a new typesetting round.",
    }

    @property
    def friendly_status(self):
        return self.FRIENDLY_STATUSES.get(self.status)

    def proofing_assignments_for_corrections(self):
        """ Returns the proofreading assignemnts for corrections
        The proofreadings relevant for round n of proofing would have been
        stored against round n-1 of this article
        """
        rounds = TypesettingRound.objects.filter(article=self.round.article)
        if rounds.count() > 1:
            previous_round = rounds[1]
            proofing_assignments = previous_round.galleyproofing_set.filter(
                completed__isnull=False,
                cancelled=False,
            )
            return proofing_assignments
        else:
            return GalleyProofing.objects.none()

    def __str__(self):
        return f'Typesetter {self.typesetter} assigned to article {self.round.article}'


class ActiveGalleyProofingManager(models.Manager):
    def get_queryset(self):
        return super(ActiveGalleyProofingManager, self).get_queryset().exclude(
            round__article__stage=submission_models.STAGE_ARCHIVED
        )


class GalleyProofing(models.Model):
    round = models.ForeignKey(
        TypesettingRound,
        on_delete=models.CASCADE,
    )
    manager = models.ForeignKey(
        'core.Account',
        null=True,
        related_name='galley_manager',
        on_delete=models.SET_NULL,
    )
    proofreader = models.ForeignKey(
        'core.Account',
        null=True,
        on_delete=models.SET_NULL,

    )
    assigned = models.DateTimeField(default=timezone.now)
    notified = models.BooleanField(default=False)
    due = models.DateTimeField(default=None, verbose_name="Date Due")
    accepted = models.DateTimeField(blank=True, null=True)
    completed = models.DateTimeField(blank=True, null=True)
    cancelled = models.BooleanField(default=False)

    task = JanewayBleachField(
        verbose_name="Proofing Task",
        help_text='Add any additional information or instructions '
                  'for the proofreader here.',
    )
    proofed_files = models.ManyToManyField('core.Galley', blank=True)
    notes = JanewayBleachField(blank=True)
    annotated_files = models.ManyToManyField('core.File', blank=True)

    objects = models.Manager()
    active_objects = ActiveGalleyProofingManager()

    class Meta:
        ordering = ('assigned', 'accepted', 'pk')

    def __str__(self):
        return 'Proofing for Article {0} by {1}'.format(
            self.round.article.title,
            self.proofreader.full_name(),
        )

    def assign(self, user=None, skip=False):
        if not skip:
            self.notified = True
            self.save()

        utils_models.LogEntry.add_entry(
            types='Proofreader Assigned',
            description='{} assigned as a proofreader by {}'.format(
                self.proofreader.full_name(),
                user,
            ),
            level='Info',
            actor=user,
            target=self.round.article,
        )

    def cancel(self, user=None):
        self.cancelled = True
        self.completed = timezone.now()
        self.save()

        utils_models.LogEntry.add_entry(
            types='Proofreading Assignment Cancelled',
            description='Proofing by {} cancelled by {}'.format(
                self.proofreader.full_name(),
                user,
            ),
            level='Info',
            actor=user,
            target=self.round.article,
        )

    def reset(self, user=None):
        self.cancelled = False
        self.completed = None
        self.accepted = None
        self.save()

        utils_models.LogEntry.add_entry(
            types='Proofreading Assignment Reset',
            description='Proofing by {} reset by {}'.format(
                self.proofreader.full_name(),
                user,
            ),
            level='Info',
            actor=user,
            target=self.round.article,
        )

    def complete(self, user=None):
        self.cancelled = False
        self.completed = timezone.now()
        self.accepted = timezone.now()
        self.save()

        utils_models.LogEntry.add_entry(
            types='Proofreading Assignment Complete',
            description='Proofing by {} completed'.format(
                user,
            ),
            level='Info',
            actor=user,
            target=self.round.article,
        )

    def unproofed_galleys(self, galleys):
        check = []
        proofed_files = self.proofed_files.all()

        for galley in galleys:
            if galley not in proofed_files:
                check.append(galley)

        return check

    @property
    def time_to_due(self):
        due = self.due.date() - timezone.now().date()

        if due == timedelta(0):
            return 'Due Today'
        elif due < timedelta(0):
            return 'Overdue'

        return '{} days'.format(due.days)

    FRIENDLY_STATUSES = {
        "assigned": "Awaiting response from the proofreader.",
        "accepted": "Proofreader has accepted task, awaiting completion.",
        "declined": "Proofreader has declined this task.",
        "completed": "The proofreader has completed their task. "
                     "You should review their response.",
        "unknown": "Task status unknown.",
        "cancelled": "Task was cancelled by manager/editor."
    }

    @property
    def status(self):
        if self.cancelled:
            return 'cancelled'
        elif self.assigned and self.accepted and not self.completed:
            return 'accepted'
        elif self.assigned and self.completed and not self.accepted:
            return 'declined'
        elif self.assigned and self.completed and self.accepted:
            return 'completed'
        elif self.assigned and not self.accepted and not self.completed:
            return 'assigned'
        else:
            return 'unknown'

    @property
    def friendly_status(self):
        return self.FRIENDLY_STATUSES.get(self.status)

    def send_assignment_notification(self, request, message, skip=False):
        description = '{0} has been assigned as a proofreader for {1}'.format(
            self.proofreader.full_name(),
            self.round.article.title,
        )

        if not skip:
            log_dict = {
                'level': 'Info',
                'action_text': description,
                'types': 'Proofing Assignment',
                'target': self.round.article,
            }
            notify_helpers.send_email_with_body_from_user(
                request,
                'Proofing Request',
                self.proofreader.email,
                message,
                log_dict=log_dict,
            )
            notify_helpers.send_slack(
                request,
                description,
                ['slack_editors'],
            )

            self.notified = True
            self.save()


class TypesettingCorrection(models.Model):
    task = models.ForeignKey(
        "typesetting.TypesettingAssignment",
        related_name="corrections",
        blank=True,
        on_delete=models.CASCADE,
    )
    galley = models.ForeignKey(
        "core.Galley",
        null=True,
        blank=True,
        on_delete=models.SET_NULL,
    )
    # A copy of the galley label, in case the galley is deleted
    label = models.CharField(max_length=255, blank=True, null=True)
    date_requested = models.DateTimeField(auto_now_add=True)
    date_completed = models.DateTimeField(blank=True, null=True)
    date_declined = models.DateTimeField(blank=True, null=True)
    # A copy of the file checksum to detect changes when requesting corrections
    file_checksum = models.CharField(max_length=255, blank=True, null=True)

    @property
    def status(self):
        _status = "pending"
        if self.date_completed:
            _status = "completed"
        elif self.date_declined:
            _status = "declined"
        return _status

    def save(self, *args, **kwargs):
        if not self.pk and not self.file_checksum:
            self.file_checksum = self.galley.file.checksum()
        super().save(*args, **kwargs)

    @property
    def corrected(self):
        if self.galley:
            return self.file_checksum != self.galley.file.checksum()
        return False