__copyright__ = "Copyright 2016-2018, Stichting SciPost (SciPost Foundation)"
__license__ = "AGPL v3"
import abc
import datetime
import json
from django.urls import reverse
from django.utils import timezone
from django.utils.html import format_html, format_html_join, html_safe
from common.utils import get_current_domain
from . import constants
from typing import TYPE_CHECKING
if TYPE_CHECKING:
from submissions.models.submission import Submission
@html_safe
class RequiredActionsDict(dict):
"""
A collection of required actions.
This dict, meant for the editors-in-charge, knows how to display itself in
various formats. Its keys are the action-codes, while its values are the texts
to present to the user.
"""
def as_data(self):
return {f: e.as_data() for f, e in self.items()}
def as_list_text(self):
return [e.__str__() for e in self.values()]
def get_json_data(self, escape_html=False):
return {f: e.get_json_data(escape_html) for f, e in self.items()}
def as_json(self, escape_html=False):
return json.dumps(self.get_json_data(escape_html))
def as_ul(self):
if not self:
return '<div class="no-actions-msg">No required actions.</div>'
return format_html(
'<ul class="actions-list">{}</ul>',
format_html_join("", "<li>{}</li>", self.values()),
)
def as_text(self):
return " ".join([action.as_text() for action in self.values()])
def __getitem__(self, action):
return super().__getitem__(action.id)
def __setitem__(self, action, val):
super().__setitem__(action.id, val)
def __contains__(self, value):
return value.id in list(self.keys())
def __str__(self):
return self.as_ul()
class BaseAction:
"""An item in the RequiredActionsDict for the Submission refereeing cycle."""
txt = ""
url = "#"
url2 = "#"
submission = None
def __init__(self, object=None, **kwargs):
self._objects = [object] if object else []
self.id = (
"%s.%i" % (object.__class__.__name__, object.id)
if object
else self.__class__.__name__
)
def __repr__(self):
return "<%s: %s>" % (self.__class__.__name__, self.id)
def _format_text(self, text, obj=None):
if obj is None and self._objects:
obj = self._objects[0]
timedelta = datetime.timedelta()
deadline = datetime.timedelta()
if hasattr(obj, "date_invited") and obj.date_invited:
timedelta = timezone.now() - obj.date_invited
if hasattr(obj, "submission"):
print
deadline = obj.submission.reporting_deadline - timezone.now()
# Add the domain name to the url so that it is clickable in the email
if self.url.startswith("/"):
base_url = "https://" + get_current_domain() + self.url
else:
base_url = self.url
return text.format(
count=len(self._objects),
object=obj.__class__.__name__,
author=obj.author.formal_str if getattr(obj, "author", None) else "",
referee=getattr(obj, "referee_str", ""),
days=timedelta.days,
deadline=deadline.days,
deadline_min=-deadline.days,
url=base_url,
url2=self.url2,
)
def as_text(self):
return " ".join([e for e in self])
def __iter__(self):
if self._objects:
for obj in self._objects:
yield format_html(self._format_text(self.txt, obj=obj))
else:
yield format_html(self._format_text(self.txt))
def __str__(self):
return self.as_text()
class VettingAction(BaseAction):
txt = '{author} has delivered a {object}. <a href="{url}">Please vet it</a>.'
@property
def url(self):
match self.id.split("."):
case "Comment", comment_id:
return reverse("comments:vet_submitted_comment", args=[comment_id])
case "Report", report_id:
return reverse("submissions:vet_submitted_report", args=[report_id])
case _:
return "{}#current-contributions".format(
reverse(
"submissions:editorial_page",
args=(self.submission.preprint.identifier_w_vn_nr,),
)
)
class NoRefereeResponseAction(BaseAction):
txt = (
"Referee {referee} has not responded for {days} days."
" Consider sending a reminder or cancelling the invitation."
)
class DeadlineAction(BaseAction):
txt = (
"Referee {referee} has accepted to send a Report "
"(with {deadline} days left), but not yet delivered it. Consider sending a reminder."
)
class OverdueAction(BaseAction):
txt = (
"Referee {referee} has accepted to send a Report "
"({deadline_min} days overdue), but not yet delivered it. Consider sending a reminder."
)
class CycleChoiceAction(BaseAction):
txt = "Choose the submission cycle to proceed with."
class NoEICRecommendationAction(BaseAction):
needs_referees = False
@property
def txt(self):
if self.needs_referees:
txt = (
"The refereeing deadline has passed and you have received no Reports yet."
' Please <a href="{url}">extend the reporting deadline</a> '
"and consider sending a reminder to your referees."
)
else:
txt = (
"The refereeing deadline has passed. Please either "
'<a href="{url}">extend it</a>, '
'or <a href="{url2}">formulate your Editorial Recommendation</a>.'
)
return txt
@property
def url(self):
return "{}#reporting-deadline".format(
reverse(
"submissions:editorial_page",
args=(self.submission.preprint.identifier_w_vn_nr,),
)
)
@property
def url2(self):
return reverse(
"submissions:eic_recommendation",
args=(self.submission.preprint.identifier_w_vn_nr,),
)
class NeedRefereesAction(BaseAction):
def __init__(self, object=None, **kwargs):
self.minimum_number_of_referees = kwargs.pop("minimum_number_of_referees")
self.current_number_of_referees = kwargs.pop("current_number_of_referees")
super().__init__(object, **kwargs)
@property
def txt(self):
if self.current_number_of_referees == 0:
text = "No Referees have yet been invited."
elif self.current_number_of_referees == 1:
text = "Only 1 Referee has yet been invited."
else:
text = (
"Only %i Referees have yet been invited."
% self.current_number_of_referees
)
text += ' At least {minimum} should be. <a href="{url}">Invite a referee here</a>.'.format(
minimum=self.minimum_number_of_referees,
url=reverse(
"submissions:select_referee",
args=(self.submission.preprint.identifier_w_vn_nr,),
),
)
return text
class BaseCycle(abc.ABC):
"""A base blueprint for the Submission refereeing cycle.
The refereeing process may be defined differently for every cycle class by its own
specific properties. The cycle class will then take care of the required actions,
permissions and the overall refereeing process.
"""
can_invite_referees = True
def __init__(self, submission: "Submission"):
self._submission = submission
self._required_actions = None
@property
def required_actions(self):
if self._required_actions is None:
self.update_required_actions()
return self._required_actions
@property
@abc.abstractmethod
def days_for_refereeing(self):
return 0
@property
def minimum_number_of_referees(self):
if (
self._submission.proceedings
and self._submission.proceedings.minimum_referees
):
return self._submission.proceedings.minimum_referees
return 3 # Three by default
def has_required_actions(self):
return bool(self.required_actions)
def add_action(self, action):
if action not in self.required_actions:
self.required_actions[action] = action
self.required_actions[action].submission = self._submission
def update_required_actions(self):
"""Gather the required actions list and populate self._required_actions."""
self._required_actions = RequiredActionsDict()
# Comments requiring vetting (including replies and recursive comments)
comments_to_vet = self._submission.comments_set_complete().awaiting_vetting()
for comment in comments_to_vet:
self.add_action(VettingAction(comment))
reports_to_vet = self._submission.reports.awaiting_vetting()
for report in reports_to_vet:
self.add_action(VettingAction(report))
# If this cycle is not the latest one in the thread, return early, skipping other actions
if not self._submission.is_latest:
return
if not self._submission.refereeing_cycle:
# Submission is a resubmission: EIC has to determine which cycle to proceed with.
self.add_action(CycleChoiceAction())
return # If no cycle is chosen. Make this a first priority!
# The EIC is late with formulating a Recommendation.
if self._submission.eic_recommendation_required:
if self._submission.reporting_deadline_has_passed:
action = NoEICRecommendationAction()
action.needs_referees = (
not self._submission.reports.non_draft().exists()
)
self.add_action(action)
if self.can_invite_referees and self._submission.in_stage_in_refereeing:
# Referees required in this cycle.
referee_invitations_count = (
self._submission.referee_invitations.non_cancelled().count()
)
# The current number of referees does not meet the minimum number of referees yet
# Except if the submission is a resubmission with vetted reports
if (referee_invitations_count < self.minimum_number_of_referees) and (
self._submission.nr_unique_thread_vetted_reports == 0
or not self._submission.is_resubmission
):
self.add_action(
NeedRefereesAction(
current_number_of_referees=referee_invitations_count,
minimum_number_of_referees=self.minimum_number_of_referees,
)
)
referee_invitations = self._submission.referee_invitations.needs_attention()
for referee_invitation in referee_invitations:
if referee_invitation.needs_response:
# Invited, but no response
self.add_action(NoRefereeResponseAction(referee_invitation))
elif referee_invitation.is_overdue:
self.add_action(OverdueAction(referee_invitation))
elif referee_invitation.needs_fulfillment_reminder:
self.add_action(DeadlineAction(referee_invitation))
def as_text(self):
"""Return a *short* description of the current status of the submission cycle."""
texts = []
recommendation = self._submission.recommendation
if recommendation:
texts.append("Thank you for formulating your Editorial Recommendation.")
if recommendation.status == constants.VOTING_IN_PREP:
texts.append(
"The Editorial Administration is now preparing it for voting."
)
elif recommendation.status == constants.PUT_TO_VOTING:
texts.append("It is now put to voting in the college.")
if self._submission.status == self._submission.RESUBMITTED:
new_sub_id = (
self._submission.get_latest_version().preprint.identifier_w_vn_nr
)
txt = (
"The Submission has been resubmitted as {identifier},"
' <a href="{url}">go to its editorial page</a>.'
)
texts.append(
txt.format(
url=reverse("submissions:editorial_page", args=(new_sub_id,)),
identifier=new_sub_id,
)
)
elif self._submission.in_stage_in_production:
texts.append(
"The SciPost production team is working on the proofs for publication."
)
elif self._submission.status == self._submission.REJECTED:
texts.append("The Submission is rejected for publication.")
elif self._submission.status == self._submission.WITHDRAWN:
texts.append("The authors have withdrawn the Submission.")
elif self._submission.status == self._submission.PUBLISHED:
texts.append("The Submission has been published as ")
for publication in self._submission.publications.published():
texts.append(
'<a href="{url}">{doi}</a> '.format(
url=publication.get_absolute_url(),
doi=publication.doi_label,
)
)
elif self._submission.status == self._submission.REFEREEING_CLOSED:
if recommendation:
texts.append("The refereeing round is closed.")
else:
texts.append(
(
"The refereeing round is closed "
"and you have not formulated an Editorial Recommendation."
)
)
if not self.required_actions and not texts:
texts.append("No action required.")
elif self.required_actions:
texts.append("<strong>Please see your required actions below.</strong>")
return format_html(" ".join(texts))
def __str__(self):
return self.as_text()
def reset_refereeing_round(self):
"""
Set the Submission status to IN_REFEREEING and reset the reporting deadline.
"""
from .models import Submission # Prevent circular import errors
deadline = timezone.now() + datetime.timedelta(days=self.days_for_refereeing)
Submission.objects.filter(id=self._submission.id).update(
status=self._submission.IN_REFEREEING,
reporting_deadline=deadline,
)
def reinvite_referees(self, referees):
"""
Duplicate and reset RefereeInvitations and send `reinvite` mail.
referees - (list of) RefereeInvitation instances
"""
from mails.utils import DirectMailUtil
# SubmissionUtils.load({'submission': self._submission})
for referee in referees:
invitation = referee
invitation.pk = None # Duplicate, do not remove the old invitation
invitation.submission = self._submission
invitation.reset_content()
invitation.date_invited = timezone.now()
invitation.save()
mail_sender = DirectMailUtil(
"referees/reinvite_contributor_to_referee", invitation=invitation
)
mail_sender.send_mail()
class RegularCycle(BaseCycle):
"""
Regular refereeing cycle, used for the first round of refereeing.
Duration differs based on the journal, according to article 3.6.3 of the by-laws.
"""
@property
def days_for_refereeing(self):
return self._submission.submitted_to.refereeing_period
class ShortCycle(BaseCycle):
"""
Short (two weeks) version of the regular refereeing cycle, used for resubmissions on request
by the editor.
"""
@property
def days_for_refereeing(self):
return 2 * 7 # 2 weeks
@property
def minimum_number_of_referees(self):
return 1
class DirectCycle(BaseCycle):
"""
Refereeing cycle without refereeing. The editor directly formulates an EICRecommendation.
"""
can_invite_referees = False
def update_required_actions(self):
"""Gather the required actions list and populate self._required_actions."""
super().update_required_actions()
# Always show `EICRec required` action disregarding the refereeing deadline.
if self._submission.eic_recommendation_required:
self.add_action(NoEICRecommendationAction())