views.py

__copyright__ = "Copyright © Stichting SciPost (SciPost Foundation)"
__license__ = "AGPL v3"


from decimal import Decimal, getcontext
import hashlib
import json
import os
import random
import string
import shutil
import requests

import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
import io, base64

from django.contrib.auth.decorators import login_required
from django.contrib.contenttypes.models import ContentType
from django.core.exceptions import PermissionDenied
from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger
from django.urls import reverse, reverse_lazy
from django.conf import settings
from django.contrib import messages
from django.db import transaction
from django.db.models import Q
from django.http import Http404, HttpResponse
from django.utils import timezone
from django.utils.decorators import method_decorator
from django.utils.html import format_html
from django.views.generic.detail import DetailView
from django.views.generic.edit import CreateView, UpdateView
from django.views.generic.list import ListView
from django.shortcuts import get_object_or_404, get_list_or_404, render, redirect

from dal import autocomplete

from .constants import (
    STATUS_DRAFT,
    ISSUES_AND_VOLUMES,
    ISSUES_ONLY,
    INDIVIDUAL_PUBLICATIONS,
)
from .exceptions import InvalidDOIError
from .models import (
    Journal,
    Volume,
    Issue,
    Publication,
    Deposit,
    DOAJDeposit,
    GenericDOIDeposit,
    PublicationAuthorsTable,
    OrgPubFraction,
    PublicationUpdate,
    AutogeneratedFileContentTemplate,
)
from .forms import (
    AbstractJATSForm,
    FundingInfoForm,
    VolumeForm,
    IssueForm,
    AuthorsTableOrganizationSelectForm,
    CreateMetadataXMLForm,
    CitationListBibitemsForm,
    ReferenceFormSet,
    CreateMetadataDOAJForm,
    DraftPublicationForm,
    PublicationGrantsForm,
    DraftAccompanyingPublicationForm,
    DraftPublicationApprovalForm,
    PublicationPublishForm,
    PublicationAuthorOrderingFormSet,
    OrgPubFractionsFormSet,
    PublicationDynSelForm,
)
from .mixins import PublicationMixin, ProdSupervisorPublicationPermissionMixin
from .services import update_citedby
from .utils import JournalUtils

from comments.models import Comment
from common.utils import get_current_domain
from funders.forms import FunderSelectForm, GrantSelectForm
from funders.models import Grant
from mails.views import MailEditorSubview
from ontology.models import AcademicField, Topic
from ontology.forms import SelectTopicForm
from organizations.models import Organization
from profiles.forms import ProfileSelectForm
from submissions.models import Submission, Report
from scipost.forms import ConfirmationForm
from scipost.models import Contributor
from scipost.mixins import PermissionsMixin, RequestViewMixin, PaginationMixin

from guardian.decorators import permission_required


################
# Autocomplete #
################


class PublicationAutocompleteView(autocomplete.Select2QuerySetView):
    """
    View to feed the Select2 widget.
    """

    def get_queryset(self):
        qs = Publication.objects.published()
        if self.q:
            qs = qs.filter(
                Q(title__icontains=self.q)
                | Q(doi_label__icontains=self.q)
                | Q(author_list__icontains=self.q)
            )
        return qs.order_by("-publication_date")

    def get_result_label(self, item):
        return format_html(
            '<strong>{}</strong><br>{}<br><span class="text-muted">by {}</span>',
            item.doi_label,
            item.title,
            item.author_list,
        )


class OwnPublicationAutocompleteView(PublicationAutocompleteView):
    """
    View to feed the Select2 widget, specialized to user's own publications.
    """

    def get_queryset(self):
        qs = self.request.user.contributor.profile.publications()
        if self.q:
            qs = qs.filter(
                Q(title__icontains=self.q)
                | Q(doi_label__icontains=self.q)
                | Q(author_list__icontains=self.q)
            )
        return qs.order_by("-publication_date")


def _hx_publication_dynsel_list(request):
    form = PublicationDynSelForm(request.POST or None)
    if form.is_valid():
        publications = form.search_results()
    else:
        publications = Publication.objects.none()
    context = {
        "publications": publications,
        "action_url_name": form.cleaned_data["action_url_name"],
        "action_url_base_kwargs": form.cleaned_data["action_url_base_kwargs"],
        "action_target_element_id": form.cleaned_data["action_target_element_id"],
    }
    return render(request, "journals/_hx_publication_dynsel_list.html", context)


################
# DOI dispatch #
################


def doi_dispatch(request, journal_tag, part_1=None, part_2=None, part_3=None, suffix=None):
    """
    Dispatch given DOI route to the appropriate view according to the Journal's settings.

    journal_tag -- Part of the DOI right before the first period.

    * part_1 (optional) -- Part of the DOI after the first period.
    * part_2 (optional) -- Part of the DOI after the second period.
    * part_3 (optional) -- Part of the DOI after the third period.
    * suffix (optional) -- Suffix of form r[number[.number]].
    """
    journal = get_object_or_404(Journal, doi_label=journal_tag)
    if suffix:
        # This DOI necessarily points to a Publication detail page:
        doi_label = (f"{journal_tag}.{part_1}{'.'+f'{part_2}' if part_2 else ''}"
                     f"{'.'+f'{part_3}' if part_3 else ''}-{suffix}")
        return publication_detail(request, doi_label)
    if part_1 is None:
        # This DOI refers to a Journal landing page.
        return journal_detail(request, journal_tag)
    elif part_2 is None:
        doi_label = "{0}.{1}".format(journal_tag, part_1)

        if journal.structure == INDIVIDUAL_PUBLICATIONS:
            # Publication DOI for invidivual publication Journals.
            return publication_detail(request, doi_label)
        elif journal.structure == ISSUES_ONLY:
            # Issue DOI for Issue only Journals.
            return issue_detail(request, doi_label)

        # The third option: a `Issue and Volume Journal DOI` would lead to a "volume detail page",
        # but that does not exist. Redirect to the Journal landing page instead.
        return journal_detail(request, journal_tag)
    elif part_3 is None:
        doi_label = "{0}.{1}.{2}".format(journal_tag, part_1, part_2)

        if journal.structure == ISSUES_AND_VOLUMES:
            # Issue DOI for Issue+Volumes Journals.
            return issue_detail(request, doi_label)
        elif journal.structure == ISSUES_ONLY:
            # Publication DOI for Issue only Journals.
            return publication_detail(request, doi_label)
    else:
        doi_label = "{0}.{1}.{2}.{3}".format(journal_tag, part_1, part_2, part_3)
        return publication_detail(request, doi_label)

    # Invalid db configure
    raise InvalidDOIError(
        {
            "journal_tag": journal_tag,
            "part_1": part_1,
            "part_2": part_2,
            "part_3": part_3,
        }
    )


############
# Journals
############


class JournalListView(ListView):
    model = Journal

    def get_queryset(self):
        qs = super().get_queryset()
        # for url /journals/?field=[acad_field_slug]
        if self.request.GET.get("field"):
            qs = qs.filter(college__acad_field__slug=self.request.GET.get("field"))
        # for url /journals/[acad_field_slug]
        if "acad_field" in self.kwargs:
            qs = qs.filter(college__acad_field=self.kwargs["acad_field"])
        return qs

    def get_context_data(self, *args, **kwargs):
        context = super().get_context_data(*args, **kwargs)
        # for url /journals/?field=[acad_field_slug]
        if self.request.GET.get("field"):
            context["acad_field"] = get_object_or_404(
                AcademicField, slug=self.request.GET.get("field")
            )
        # for url /journals/[acad_field_slug]
        if "acad_field" in self.kwargs:
            context["acad_field"] = self.kwargs["acad_field"]
        return context


class PublicationListView(PaginationMixin, ListView):
    """
    Show Publications filtered per specialty.
    """

    queryset = Publication.objects.published()
    paginate_by = 10

    def get_queryset(self):
        qs = super().get_queryset()
        if self.request.GET.get("journal"):
            qs = qs.for_journal(self.request.GET["journal"])

        if self.request.GET.get("issue"):
            try:
                issue = int(self.request.GET["issue"])
            except ValueError:
                issue = None
            if issue:
                qs = qs.filter(in_issue__id=issue)
        if self.request.GET.get("specialty"):
            qs = qs.for_specialty(self.request.GET["specialty"])

        if self.request.GET.get("orderby") == "citations":
            qs = qs.order_by("-number_of_citations")
        else:
            qs = qs.order_by("-publication_date", "-paper_nr")
        return qs

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        return context


def journal_detail(request, doi_label):
    """Journal details page.

    The landing page of a Journal lists either the latest and the current issue of a Journal
    or paginates its individual Publications.
    """
    journal = get_object_or_404(Journal, doi_label=doi_label)
    accepted_submission_ids = [
        sub.id
        for sub in Submission.objects.accepted()
        if sub.editorial_decision.for_journal == journal
    ]
    context = {
        "journal": journal,
        "most_cited": Publication.objects.for_journal(journal.name)
        .published()
        .most_cited(5),
        "latest_publications": Publication.objects.for_journal(
            journal.name
        ).published()[:5],
        "accepted_submissions": Submission.objects.accepted()
        .filter(pk__in=accepted_submission_ids)
        .order_by("-latest_activity"),
    }
    return render(request, "journals/journal_detail.html", context)


class VolumesAdminListView(PermissionsMixin, PaginationMixin, ListView):
    """
    Admin: List all Volumes in the database.
    """

    model = Volume
    permission_required = "scipost.can_manage_issues"
    paginate_by = 20


class VolumesAdminAddView(PermissionsMixin, CreateView):
    """
    Admin: Create new Volume.
    """

    model = Volume
    form_class = VolumeForm
    success_url = reverse_lazy("journals:admin_volumes_list")
    permission_required = "scipost.can_manage_issues"


class VolumesAdminUpdateView(PermissionsMixin, UpdateView):
    """
    Admin: Update Volume instance.
    """

    model = Volume
    form_class = VolumeForm
    slug_field = slug_url_kwarg = "doi_label"
    success_url = reverse_lazy("journals:admin_volumes_list")
    permission_required = "scipost.can_manage_issues"


class IssuesView(DetailView):
    """
    List all Issues sorted per Journal.
    """

    queryset = Journal.objects.has_issues()
    slug_field = slug_url_kwarg = "doi_label"
    template_name = "journals/journal_issues.html"


class IssuesAdminListView(PermissionsMixin, PaginationMixin, ListView):
    """
    Admin: List all Issues in the database.
    """

    model = Issue
    permission_required = "scipost.can_manage_issues"
    paginate_by = 20


class IssuesAdminAddView(PermissionsMixin, CreateView):
    """
    Admin: Create new Issue.
    """

    model = Issue
    form_class = IssueForm
    success_url = reverse_lazy("journals:admin_issue_list")
    permission_required = "scipost.can_manage_issues"


class IssuesAdminUpdateView(PermissionsMixin, UpdateView):
    """
    Admin: Update issue instance.
    """

    model = Issue
    form_class = IssueForm
    slug_field = slug_url_kwarg = "doi_label"
    success_url = reverse_lazy("journals:admin_issue_list")
    permission_required = "scipost.can_manage_issues"


def authoring(request, doi_label=None):
    """Author information for a given Journal, or in general if no doi_label in given."""
    context = {}
    if doi_label:
        journal = get_object_or_404(Journal, doi_label=doi_label)
        context = {"journal": journal}
    return render(request, "journals/authoring.html", context)


def refereeing(request, doi_label=None):
    """Author information for a given Journal, or in general if no doi_label in given."""
    context = {}
    if doi_label:
        journal = get_object_or_404(Journal, doi_label=doi_label)
        context = {"journal": journal}
    return render(request, "journals/refereeing.html", context)


def redirect_to_about(request, doi_label):
    journal = get_object_or_404(Journal, doi_label=doi_label)
    return redirect(
        reverse("journal:about", kwargs={"doi_label": journal.doi_label}),
        permanent=True,
    )


def about(request, doi_label):
    """Journal specific about page."""
    journal = get_object_or_404(Journal, doi_label=doi_label)
    year = timezone.now().year
    nr_publications = journal.nr_publications(year=year)
    nr_publications_1 = journal.nr_publications(year=year - 1)
    nr_publications_2 = journal.nr_publications(year=year - 2)
    nr_citations = journal.nr_citations(year=year)
    nr_citations_1 = journal.nr_citations(year=year - 1)
    nr_citations_2 = journal.nr_citations(year=year - 2)
    citedby_citescore = journal.citedby_citescore(year=year)
    citedby_citescore_1 = journal.citedby_citescore(year=year - 1)
    citedby_citescore_2 = journal.citedby_citescore(year=year - 2)
    citedby_impact_factor_1 = journal.citedby_impact_factor(year - 1)
    citedby_impact_factor_2 = journal.citedby_impact_factor(year - 2)
    context = {
        "journal": journal,
        "nr_publications": nr_publications,
        "nr_publications_1": nr_publications_1,
        "nr_publications_2": nr_publications_2,
        "nr_citations": nr_citations,
        "nr_citations_1": nr_citations_1,
        "nr_citations_2": nr_citations_2,
        "citedby_citescore": citedby_citescore,
        "citedby_citescore_1": citedby_citescore_1,
        "citedby_citescore_2": citedby_citescore_2,
        "citedby_impact_factor_1": citedby_impact_factor_1,
        "citedby_impact_factor_2": citedby_impact_factor_2,
    }
    return render(request, "journals/about.html", context)


def provide_plot(x, y, name, nonce=None):
    fig, ax = plt.subplots()
    ax.bar(x, y)
    ax.set_title(name)
    flike = io.BytesIO()
    fig.savefig(flike)
    return base64.b64encode(flike.getvalue()).decode()


def metrics(request, doi_label, specialty=None):
    journal = get_object_or_404(Journal, doi_label=doi_label)
    context = {
        "journal": journal,
        "specialty": specialty,
    }
    key = "all"
    if specialty:
        key = specialty.slug
    nr_publications_plot = provide_plot(
        x=journal.cf_metrics["nr_publications"]["years"],
        y=journal.cf_metrics["nr_publications"]["nr_publications"][key],
        name="publications",
        nonce=request.csp_nonce,
    )
    nr_submissions_plot = provide_plot(
        x=journal.cf_metrics["nr_submissions"]["years"],
        y=journal.cf_metrics["nr_submissions"]["nr_submissions"][key],
        name="submissions",
        nonce=request.csp_nonce,
    )
    nr_citations_plot = provide_plot(
        x=journal.cf_metrics["nr_citations"]["years"],
        y=journal.cf_metrics["nr_citations"]["nr_citations"][key],
        name="citations",
        nonce=request.csp_nonce,
    )
    citescore_plot = provide_plot(
        x=journal.cf_metrics["citedby_citescore"]["years"],
        y=journal.cf_metrics["citedby_citescore"]["citedby_citescore"][key],
        name="citations",
        nonce=request.csp_nonce,
    )
    impact_factor_plot = provide_plot(
        x=journal.cf_metrics["citedby_impact_factor"]["years"],
        y=journal.cf_metrics["citedby_impact_factor"]["citedby_impact_factor"][key],
        name="citations",
        nonce=request.csp_nonce,
    )
    context["nr_publications_plot"] = nr_publications_plot
    context["nr_submissions_plot"] = nr_submissions_plot
    context["nr_citations_plot"] = nr_citations_plot
    context["citescore_plot"] = citescore_plot
    context["impact_factor_plot"] = impact_factor_plot
    return render(request, "journals/metrics.html", context)


def issue_detail(request, doi_label):
    """Issue detail page."""
    issue = get_object_or_404(Issue.objects.open_or_published(), doi_label=doi_label)
    journal = issue.in_journal or issue.in_volume.in_journal

    papers = issue.publications.published().order_by("paper_nr")
    next_issue = (
        Issue.objects.published()
        .filter(start_date__gt=issue.start_date)
        .filter(
            Q(in_volume__in_journal=journal) | Q(in_journal=journal),
        )
        .distinct()
        .order_by("start_date")
        .first()
    )
    prev_issue = (
        Issue.objects.published()
        .filter(start_date__lt=issue.start_date)
        .filter(Q(in_volume__in_journal=journal) | Q(in_journal=journal))
        .distinct()
        .order_by("start_date")
        .last()
    )

    context = {
        "issue": issue,
        "prev_issue": prev_issue,
        "next_issue": next_issue,
        "papers": papers,
        "journal": journal,
    }
    return render(request, "journals/journal_issue_detail.html", context)


#######################
# Publication process #
#######################
class PublicationGrantsView(PermissionsMixin, UpdateView):
    """Add/update grants associated to a Publication."""

    permission_required = "scipost.can_draft_publication"
    queryset = Publication.objects.drafts()
    slug_field = slug_url_kwarg = "doi_label"
    form_class = PublicationGrantsForm
    template_name = "journals/grants_form.html"


class PublicationGrantsRemovalView(PermissionsMixin, DetailView):
    """
    Remove grant associated to a Publication.
    """

    permission_required = "scipost.can_draft_publication"
    queryset = Publication.objects.drafts()
    slug_field = slug_url_kwarg = "doi_label"

    def get(self, request, *args, **kwargs):
        super().get(request, *args, **kwargs)
        grant = get_object_or_404(Grant, id=kwargs.get("grant_id"))
        self.object.grants.remove(grant)
        return redirect(
            reverse("journals:update_grants", args=(self.object.doi_label,))
        )


@permission_required("scipost.can_draft_publication", raise_exception=True)
def publication_authors_ordering(request, doi_label):
    publication = get_object_or_404(Publication, doi_label=doi_label)
    if not publication.is_draft and not request.user.has_perm(
        "scipost.can_publish_accepted_submission"
    ):
        raise Http404("You do not have permission to edit this non-draft Publication")
    formset = PublicationAuthorOrderingFormSet(
        request.POST or None, queryset=publication.authors.order_by("order")
    )
    if formset.is_valid():
        formset.save()
        messages.success(request, "Author ordering updated")
        return redirect(publication.get_absolute_url())
    context = {
        "formset": formset,
        "publication": publication,
    }
    return render(request, "journals/publication_authors_form.html", context)


class DraftPublicationCreateView(PermissionsMixin, CreateView):
    """
    Create a draft of a Publication.
    """

    permission_required = "scipost.can_draft_publication"
    model = Publication
    form_class = DraftPublicationForm
    template_name = "journals/publication_form.html"

    def get_form_kwargs(self):
        kwargs = super().get_form_kwargs()
        kwargs["identifier_w_vn_nr"] = self.kwargs.get("identifier_w_vn_nr")
        kwargs["issue_id"] = self.request.GET.get("issue")
        return kwargs


class DraftPublicationUpdateView(PermissionsMixin, UpdateView):
    """
    Any Production Officer or Administrator can draft a new publication without publishing here.
    The actual publishing is done at a later stage, after the draft has been finished.
    """

    permission_required = "scipost.can_draft_publication"
    queryset = Publication.objects.unpublished()
    slug_url_kwarg = "doi_label"
    slug_field = "doi_label"
    form_class = DraftPublicationForm
    template_name = "journals/publication_form.html"

    def get_object(self, queryset=None):
        publication = Publication.objects.get(doi_label=self.kwargs.get("doi_label"))
        if publication.status == STATUS_DRAFT:
            return publication
        if self.request.user.has_perm("scipost.can_publish_accepted_submission"):
            return publication
        raise Http404("Found Publication is not in draft")

    def get_form_kwargs(self):
        kwargs = super().get_form_kwargs()
        kwargs["identifier_w_vn_nr"] = self.kwargs.get("identifier_w_vn_nr")
        kwargs["issue_id"] = self.request.GET.get("issue")
        return kwargs


@permission_required("scipost.can_publish_accepted_submission", raise_exception=True)
def view_autogenerated_file(request, doi_label, autotemplate_id):
    publication = get_object_or_404(Publication, doi_label=doi_label)
    autotemplate = get_object_or_404(AutogeneratedFileContentTemplate, pk=autotemplate_id)
    file_contents = string.Template(autotemplate.content_template_string).substitute(
        title=publication.title,
        author_list=publication.author_list,
        doi_string=publication.doi_string,
        absolute_url=f"https://{request.get_host()}{publication.get_absolute_url()}",
        citation=publication.citation,
        publication_date=publication.publication_date.strftime("%Y-%m-%d"),
        license=publication.cc_license,
        resources=publication.resources_as_md(),
    )
    context = {
        "publication": publication,
        "autotemplate": autotemplate,
        "file_contents": file_contents,
    }
    return render(request, "journals/publication_view_autogenerated_file.html", context)


@permission_required("scipost.can_draft_publication", raise_exception=True)
def draft_accompanying_publication(request, doi_label):
    anchor = get_object_or_404(Publication, doi_label=doi_label)
    if request.method == "POST":
        form = DraftAccompanyingPublicationForm(request.POST)
        if form.is_valid():
            companion = form.save()
            return redirect(companion.get_absolute_url())
    else:
        form = DraftAccompanyingPublicationForm(
            initial={
                "anchor": anchor,
                "title": anchor.title,
                "abstract": anchor.abstract,
            }
        )
    context = {"anchor": anchor, "form": form,}
    return render(request, "journals/draft_accompanying_publication.html", context)


class DraftPublicationApprovalView(PermissionsMixin, UpdateView):
    permission_required = "scipost.can_draft_publication"
    queryset = Publication.objects.drafts()
    slug_field = slug_url_kwarg = "doi_label"
    form_class = DraftPublicationApprovalForm
    template_name = "journals/publication_approval_form.html"


@method_decorator(transaction.atomic, name="dispatch")
class PublicationPublishView(PermissionsMixin, RequestViewMixin, UpdateView):
    permission_required = "scipost.can_publish_accepted_submission"
    queryset = Publication.objects.unpublished()
    slug_field = slug_url_kwarg = "doi_label"
    form_class = PublicationPublishForm
    template_name = "journals/publication_publish_form.html"


@permission_required("scipost.can_publish_accepted_submission", return_403=True)
def manage_metadata(request, doi_label=None):

    if doi_label:
        publication = get_object_or_404(Publication, doi_label=doi_label)
        associate_grant_form = GrantSelectForm()
        associate_generic_funder_form = FunderSelectForm()
        context = {
            "publication": publication,
            "associate_grant_form": associate_grant_form,
            "associate_generic_funder_form": associate_generic_funder_form,
        }
        return render(request, "journals/manage_metadata_for_publication.html", context)

    publications_list = Publication.objects.all()
    # Use Paginator to reduce request size.
    paginator = Paginator(publications_list, 20)
    page = request.GET.get("page")
    try:
        publications = paginator.page(page)
    except PageNotAnInteger:
        # If page is not an integer, deliver first page.
        publications = paginator.page(1)
    except EmptyPage:
        # If page is out of range (e.g. 9999), deliver last page of results.
        publications = paginator.page(paginator.num_pages)

    context = {
        "publications": publications,
        "page_obj": publications,
        "paginator": paginator,
    }
    return render(request, "journals/manage_metadata.html", context)


@permission_required("scipost.can_draft_publication", return_403=True)
@transaction.atomic
def add_author(request, doi_label):
    """
    Link authors (via their Profile) to a Publication.

    To be used for registered Contributors who have not claimed authorship,
    as well as for unregistered authors.

    This is important for the Crossref metadata, in which all authors must appear.
    """
    publication = get_object_or_404(Publication, doi_label=doi_label)
    if not publication.is_draft and not request.user.has_perm(
        "can_publish_accepted_submission"
    ):
        raise Http404("You do not have permission to edit this non-draft Publication")

    form = ProfileSelectForm(request.POST or None)
    if request.POST and form.is_valid():
        table, created = PublicationAuthorsTable.objects.get_or_create(
            publication=publication, profile=form.cleaned_data["profile"]
        )
        if created:
            messages.success(request, "Added {} as an author.".format(table.profile))
        else:
            messages.warning(
                request,
                (
                    "Author {} was already associated to this "
                    "Publication.".format(table.profile)
                ),
            )
        return redirect(publication.get_absolute_url())
    context = {
        "publication": publication,
        "form": form,
    }
    return render(request, "journals/add_author.html", context)


class AuthorAffiliationView(PublicationMixin, PermissionsMixin, DetailView):
    """
    Handle the author affiliations for a Publication.
    """

    permission_required = "scipost.can_draft_publication"
    template_name = "journals/author_affiliations.html"

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context["add_affiliation_form"] = AuthorsTableOrganizationSelectForm()
        return context


@permission_required("scipost.can_draft_publication", return_403=True)
@transaction.atomic
def add_affiliation(request, doi_label, pk):
    """
    Adds an affiliation to a PublicationAuthorsTable.
    """
    table = get_object_or_404(PublicationAuthorsTable, pk=pk)
    form = AuthorsTableOrganizationSelectForm(request.POST or None)
    if form.is_valid():
        table.affiliations.add(form.cleaned_data["organization"])
        table.save()
        Publication.objects.filter(id=table.publication.id).update(
            cf_author_affiliation_indices_list=[]
        )  # force recompute it
        return redirect(
            reverse("journals:author_affiliations", kwargs={"doi_label": doi_label})
        )
    context = {"table": table, "add_affiliation_form": form}
    return render(request, "journals/author_affiliation_add.html", context)


@permission_required("scipost.can_draft_publication", return_403=True)
@transaction.atomic
def remove_affiliation(request, doi_label, pk, organization_id):
    """
    Remove an affiliation in a PublicationAuthorsTable.
    """
    table = get_object_or_404(PublicationAuthorsTable, pk=pk)
    org = get_object_or_404(Organization, pk=organization_id)
    table.affiliations.remove(org)
    table.save()
    Publication.objects.filter(id=table.publication.id).update(
        cf_author_affiliation_indices_list=[]
    )  # force recompute it
    return redirect(
        reverse("journals:author_affiliations", kwargs={"doi_label": doi_label})
    )


@permission_required("scipost.can_draft_publication", return_403=True)
def update_references(request, doi_label):
    """
    Update the References for a certain Publication.
    """
    publication = get_object_or_404(Publication, doi_label=doi_label)
    if not publication.is_draft and not request.user.has_perm(
        "scipost.can_publish_accepted_submission"
    ):
        raise Http404("You do not have permission to edit this non-draft Publication")

    references = publication.references.all()
    formset = ReferenceFormSet(
        request.POST or None,
        queryset=references,
        publication=publication,
        extra=request.GET.get("extra"),
    )

    if request.GET.get("prefill"):
        formset.prefill()

    if formset.is_valid():
        formset.save()
        messages.success(request, "References saved")
        return redirect(publication.get_absolute_url())

    context = {
        "publication": publication,
        "formset": formset,
    }
    return render(request, "journals/update_references.html", context)


class CitationUpdateView(
    PublicationMixin, ProdSupervisorPublicationPermissionMixin, UpdateView
):
    """
    Populates the citation_list dictionary entry in the metadata field in a Publication instance.
    """

    form_class = CitationListBibitemsForm
    template_name = "journals/create_citation_list_metadata.html"

    def get_success_url(self):
        return reverse_lazy(
            "journals:create_citation_list_metadata",
            kwargs={"doi_label": self.object.doi_label},
        )


class AbstractJATSUpdateView(
    PublicationMixin, ProdSupervisorPublicationPermissionMixin, UpdateView
):
    """
    Add or update the JATS version of the abstract.
    This should be produced separately using pandoc.
    """

    form_class = AbstractJATSForm
    template_name = "journals/create_abstract_jats.html"


class FundingInfoView(
    PublicationMixin, ProdSupervisorPublicationPermissionMixin, UpdateView
):
    """
    Add/update funding statement to the xml_metadata
    """

    form_class = FundingInfoForm
    template_name = "journals/create_funding_info_metadata.html"


@permission_required("scipost.can_draft_publication", return_403=True)
@transaction.atomic
def add_associated_grant(request, doi_label):
    """
    Called by an Editorial Administrator.
    This associates a grant from the database to this publication.
    """
    publication = get_object_or_404(Publication, doi_label=doi_label)
    if not publication.is_draft and not request.user.has_perm(
        "scipost.can_publish_accepted_submission"
    ):
        raise Http404("You do not have permission to edit this non-draft Publication")
    grant_select_form = GrantSelectForm(request.POST or None)
    if grant_select_form.is_valid():
        publication.grants.add(grant_select_form.cleaned_data["grant"])
        publication.doideposit_needs_updating = True
        publication.save()
        messages.success(request, "Grant added to publication %s" % str(publication))
    return redirect(publication.get_absolute_url())


@permission_required("scipost.can_draft_publication", return_403=True)
@transaction.atomic
def add_generic_funder(request, doi_label):
    """
    Called by an Editorial Administrator.
    This associates a funder (generic, not via grant) from the database to this publication.
    """
    publication = get_object_or_404(Publication, doi_label=doi_label)
    if not publication.is_draft and not request.user.has_perm(
        "scipost.can_publish_accepted_submission"
    ):
        raise Http404("You do not have permission to edit this non-draft Publication")
    funder_select_form = FunderSelectForm(request.POST or None)
    if funder_select_form.is_valid():
        publication.funders_generic.add(funder_select_form.cleaned_data["funder"])
        publication.save()
        messages.success(
            request, "Generic funder added to publication %s" % str(publication)
        )
    return redirect(publication.get_absolute_url())


class CreateMetadataXMLView(
    PublicationMixin, ProdSupervisorPublicationPermissionMixin, UpdateView
):
    """
    To be called by an EdAdmin (or Production Supervisor) after the authors,
    author ordering, affiliations, citation_list, funding_info
    entries have been filled. Populates the metadata_xml field of a Publication instance.
    The contents can then be sent to Crossref for registration.
    """

    form_class = CreateMetadataXMLForm
    template_name = "journals/create_metadata_xml.html"


@permission_required("scipost.can_draft_publication", return_403=True)
@transaction.atomic
def metadata_xml_deposit(request, doi_label, option="test"):
    """
    Crossref metadata deposit.
    If test==True, test the metadata_xml using the Crossref test server.
    Makes use of the python requests module.
    """
    publication = get_object_or_404(Publication, doi_label=doi_label)
    if not publication.is_draft and not request.user.has_perm(
        "scipost.can_publish_accepted_submission"
    ):
        raise Http404("You do not have permission to access this non-draft Publication")
    if (
        not request.user.has_perm("scipost.can_publish_accepted_submission")
        and option != "test"
    ):
        raise PermissionDenied(
            "You do not have permission to do real Crossref deposits"
        )

    if publication.metadata_xml is None:
        messages.warning(
            request,
            "This publication has no metadata. Produce it first before saving it.",
        )
        return redirect(
            reverse(
                "journals:create_metadata_xml",
                kwargs={"doi_label": publication.doi_label},
            )
        )

    timestamp = publication.metadata_xml.partition("<timestamp>")[2].partition(
        "</timestamp>"
    )[0]
    doi_batch_id = publication.metadata_xml.partition("<doi_batch_id>")[2].partition(
        "</doi_batch_id>"
    )[0]

    # Find Crossref xml files
    path = ""
    if publication.in_issue:
        path += "{issue_path}/{paper_nr}/{doi_label}_Crossref".format(
            issue_path=publication.in_issue.path,
            paper_nr=publication.get_paper_nr(),
            doi_label=publication.doi_label.replace(".", "_"),
        )