views.py

import hashlib
import json
import os
import random
import requests
import shutil
import string
import xml.etree.ElementTree as ET

from django.contrib.auth.decorators import login_required
from django.contrib.contenttypes.models import ContentType
from django.core.urlresolvers import reverse
from django.conf import settings
from django.contrib import messages
from django.http import Http404
from django.utils import timezone
from django.shortcuts import get_object_or_404, render, redirect
from django.db import transaction
from django.http import HttpResponse

from .exceptions import PaperNumberingError
from .helpers import paper_nr_string, issue_doi_label_from_doi_label
from .models import Journal, Issue, Publication, UnregisteredAuthor, Deposit, DOAJDeposit,\
                    GenericDOIDeposit
from .forms import FundingInfoForm, InitiatePublicationForm, ValidatePublicationForm,\
                   UnregisteredAuthorForm, CreateMetadataXMLForm, CitationListBibitemsForm
from .utils import JournalUtils

from comments.models import Comment
from funders.models import Funder
from submissions.models import Submission, Report
from scipost.models import Contributor
from production.constants import PROOFS_PUBLISHED
from production.models import ProductionEvent
from production.signals import notify_stream_status_change

from funders.forms import FunderSelectForm, GrantSelectForm
from scipost.forms import ConfirmationForm

from guardian.decorators import permission_required


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

def journals(request):
    '''Main landing page for Journals application.'''
    context = {'journals': Journal.objects.order_by('name')}
    return render(request, 'journals/journals.html', context)


def landing_page(request, doi_label):
    journal = get_object_or_404(Journal, doi_label=doi_label)

    current_issue = Issue.objects.published(
        in_volume__in_journal=journal,
        start_date__lte=timezone.now(),
        until_date__gte=timezone.now()).order_by('-until_date').first()
    latest_issue = Issue.objects.published(
        in_volume__in_journal=journal,
        until_date__lte=timezone.now()).order_by('-until_date').first()

    prev_issue = None
    if current_issue:
        prev_issue = (Issue.objects.published(in_volume__in_journal=journal,
                                              start_date__lt=current_issue.start_date)
                                   .order_by('start_date').last())

    context = {
        'current_issue': current_issue,
        'latest_issue': latest_issue,
        'prev_issue': prev_issue,
        'journal': journal
    }
    return render(request, 'journals/journal_landing_page.html', context)


def issues(request, doi_label):
    journal = get_object_or_404(Journal, doi_label=doi_label)

    issues = Issue.objects.published(in_volume__in_journal=journal).order_by('-until_date')
    context = {
        'issues': issues,
        'journal': journal
    }
    return render(request, 'journals/journal_issues.html', context)


def recent(request, doi_label):
    """
    Display page for the most recent 20 publications in SciPost Physics.
    """
    journal = get_object_or_404(Journal, doi_label=doi_label)
    recent_papers = Publication.objects.published(
        in_issue__in_volume__in_journal=journal).order_by('-publication_date',
                                                          '-paper_nr')[:20]
    context = {
        'recent_papers': recent_papers,
        'journal': journal,
    }
    return render(request, 'journals/journal_recent.html', context)


def accepted(request, doi_label):
    """
    Display page for submissions to SciPost Physics which
    have been accepted but are not yet published.
    """
    journal = get_object_or_404(Journal, doi_label=doi_label)
    accepted_SP_submissions = (Submission.objects.accepted()
                               .filter(submitted_to_journal=journal.name)
                               .order_by('-latest_activity'))
    context = {
        'accepted_SP_submissions': accepted_SP_submissions,
        'journal': journal
    }
    return render(request, 'journals/journal_accepted.html', context)


def info_for_authors(request, doi_label):
    journal = get_object_or_404(Journal, doi_label=doi_label)
    context = {
        'journal': journal
    }
    return render(request, 'journals/%s_info_for_authors.html' % doi_label, context)


def about(request, doi_label):
    journal = get_object_or_404(Journal, doi_label=doi_label)
    context = {
        'journal': journal
    }
    return render(request, 'journals/%s_about.html' % doi_label, context)


def issue_detail(request, doi_label):
    issue = Issue.objects.get_published(doi_label=doi_label)
    journal = issue.in_volume.in_journal

    papers = issue.publication_set.order_by('paper_nr')
    next_issue = (Issue.objects.published(in_volume__in_journal=journal,
                                          start_date__gt=issue.start_date)
                               .order_by('start_date').first())
    prev_issue = (Issue.objects.published(in_volume__in_journal=journal,
                                          start_date__lt=issue.start_date)
                               .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 #
#######################

@permission_required('scipost.can_publish_accepted_submission', return_403=True)
@transaction.atomic
def initiate_publication(request):
    """
    Called by an Editorial Administrator.
    Publish the manuscript after proofs have been accepted.
    This method prefills a ValidatePublicationForm for further
    processing (verification in validate_publication method).
    """
    initiate_publication_form = InitiatePublicationForm(request.POST or None)
    if initiate_publication_form.is_valid():
        submission = initiate_publication_form.cleaned_data['accepted_submission']
        current_issue = initiate_publication_form.cleaned_data['to_be_issued_in']

        # Determine next available paper number:
        paper_nr = Publication.objects.filter(in_issue__in_volume=current_issue.in_volume).count()
        paper_nr += 1
        if paper_nr > 999:
            raise PaperNumberingError(paper_nr)

        # Build form data
        doi_label = (
            current_issue.in_volume.in_journal.name
            + '.' + str(current_issue.in_volume.number)
            + '.' + str(current_issue.number) + '.' + paper_nr_string(paper_nr)
        )
        doi_string = '10.21468/' + doi_label
        BiBTeX_entry = (
            '@Article{' + doi_label + ',\n'
            '\ttitle={{' + submission.title + '}},\n'
            '\tauthor={' + submission.author_list.replace(',', ' and') + '},\n'
            '\tjournal={'
            + current_issue.in_volume.in_journal.get_abbreviation_citation()
            + '},\n'
            '\tvolume={' + str(current_issue.in_volume.number) + '},\n'
            '\tissue={' + str(current_issue.number) + '},\n'
            '\tpages={' + paper_nr_string(paper_nr) + '},\n'
            '\tyear={' + current_issue.until_date.strftime('%Y') + '},\n'
            '\tpublisher={SciPost},\n'