def quick_assign(request, article):
errors = []
try:
default_review_form_id = setting_handler.get_setting(
'general', 'default_review_form', request.journal).processed_value
except models.ReviewForm.DoesNotExist:
errors.append('This journal has no default review form.')
try:
review_form = models.ReviewForm.objects.get(pk=default_review_form_id)
except ValueError:
errors.append('Default review form is not an integer.')
try:
default_visibility = setting_handler.get_setting(
'general', 'default_review_visibility', request.journal).value
default_due = setting_handler.get_setting('general',
'default_review_days',
request.journal).value
except BaseException:
errors.append(
'This journal does not have either default visibilty or default due.'
)
user_id = request.POST.get('quick_assign')
user = core_models.Account.objects.get(pk=user_id)
if user not in request.journal.users_with_role('reviewer'):
errors.append('This user is not a reviewer for this journal.')
if not errors:
new_assignment = models.ReviewAssignment.objects.create(
article=article,
reviewer=user,
editor=request.user,
review_round=article.current_review_round_object(),
form=review_form,
access_code=uuid4(),
visibility=default_visibility,
date_due=timezone.now() + timedelta(days=int(default_due)),
)
article.stage = submission_models.STAGE_UNDER_REVIEW
article.save()
email_content = get_reviewer_notification(request, article,
request.user, new_assignment)
kwargs = {
'user_message_content': email_content,
'review_assignment': new_assignment,
'request': request,
'skip': False,
'acknowledgement': False
}
event_logic.Events.raise_event(
event_logic.Events.ON_REVIEWER_REQUESTED, **kwargs)
event_logic.Events.raise_event(
event_logic.Events.ON_REVIEWER_REQUESTED_ACKNOWLEDGE, **kwargs)
return new_assignment
else:
for error in errors:
messages.add_message(request, messages.WARNING, error)
def supp_file_doi(request, article_id, supp_file_id):
"""
Presents an interface for minting a supplementary file DOI
:param request: HttpRequest
:param article_id: Article object PK
:param supp_file_id: SupplementaryFile PK
:return: HttpResponse or HttpRedirect
"""
article = get_object_or_404(
submission_models.Article,
pk=article_id,
journal=request.journal,
)
supplementary_file = get_object_or_404(
core_models.SupplementaryFile,
pk=supp_file_id,
)
test_mode = setting_handler.get_setting('Identifiers', 'crossref_test',
article.journal).processed_value
if not article.get_doi():
messages.add_message(
request, messages.INFO,
'Parent article must have a DOI before you can assign a'
'supplementary file a DOI.')
xml_context = {
'supp_file':
supplementary_file,
'article':
article,
'batch_id':
uuid.uuid4(),
'timestamp':
int(
round((datetime.datetime.now() -
datetime.datetime(1970, 1, 1)).total_seconds())),
'depositor_name':
setting_handler.get_setting('Identifiers', 'crossref_name',
article.journal).processed_value,
'depositor_email':
setting_handler.get_setting('Identifiers', 'crossref_email',
article.journal).processed_value,
'registrant':
setting_handler.get_setting('Identifiers', 'crossref_registrant',
article.journal).processed_value,
'parent_doi':
article.get_doi()
}
xml_content = render_to_string('identifiers/crossref_component.xml',
xml_context, request)
if request.POST:
from identifiers import logic
logic.register_crossref_component(article, xml_content,
supplementary_file)
supplementary_file.doi = '{0}.{1}'.format(article.get_doi(),
supplementary_file.pk)
supplementary_file.save()
return redirect(
reverse('production_article', kwargs={'article_id': article.pk}))
template = 'production/supp_file_doi.html'
context = {
'article': article,
'supp_file': supplementary_file,
'xml_content': xml_content,
'test_mode': test_mode,
}
return render(request, template, context)
def create_article_with_review_content(article_dict, journal, auth_file,
base_url):
date_started = timezone.make_aware(
dateparser.parse(article_dict.get('date_submitted')))
# Create a base article
article = models.Article(
journal=journal,
title=article_dict.get('title'),
abstract=article_dict.get('abstract'),
language=article_dict.get('language'),
stage=models.STAGE_UNDER_REVIEW,
is_import=True,
date_submitted=date_started,
)
article.save()
# Check for editors and assign them as section editors.
editors = article_dict.get('editors', [])
for editor in editors:
try:
account = core_models.Account.objects.get(email=editor)
account.add_account_role('section-editor', journal)
review_models.EditorAssignment.objects.create(
article=article, editor=account, editor_type='section-editor')
logger.info('Editor added to article')
except Exception as e:
logger.error('Editor account was not found.')
logger.exception(e)
# Add a new review round
round = review_models.ReviewRound.objects.create(article=article,
round_number=1)
# Add keywords
keywords = article_dict.get('keywords')
if keywords:
for keyword in keywords.split(';'):
word, created = models.Keyword.objects.get_or_create(word=keyword)
article.keywords.add(word)
# Add authors
for author in article_dict.get('authors'):
try:
author_record = core_models.Account.objects.get(
email=author.get('email'))
except core_models.Account.DoesNotExist:
author_record = core_models.Account.objects.create(
email=author.get('email'),
first_name=author.get('first_name'),
last_name=author.get('last_name'),
institution=author.get('affiliation'),
biography=author.get('bio'),
)
# If we have a country, fetch its record
if author.get('country'):
try:
country = core_models.Country.objects.get(
code=author.get('country'))
author_record.country = country
author_record.save()
except core_models.Country.DoesNotExist:
pass
# Add authors to m2m and create an order record
article.authors.add(author_record)
models.ArticleAuthorOrder.objects.create(
article=article,
author=author_record,
order=article.next_author_sort())
# Set the primary author
article.owner = core_models.Account.objects.get(
email=article_dict.get('correspondence_author'))
article.correspondence_author = article.owner
# Get or create the article's section
try:
section = models.Section.objects.language().fallbacks('en').get(
journal=journal, name=article_dict.get('section'))
except models.Section.DoesNotExist:
section = None
article.section = section
article.save()
# Attempt to get the default review form
form = setting_handler.get_setting('general',
'default_review_form',
journal,
create=True).processed_value
if not form:
try:
form = review_models.ReviewForm.objects.filter(journal=journal)[0]
except Exception:
form = None
logger.error(
'You must have at least one review form for the journal before'
' importing.')
exit()
for review in article_dict.get('reviews'):
try:
reviewer = core_models.Account.objects.get(
email=review.get('email'))
except core_models.Account.DoesNotExist:
reviewer = core_models.Account.objects.create(
email=review.get('email'),
first_name=review.get('first_name'),
last_name=review.get('last_name'),
)
# Parse the dates
date_requested = timezone.make_aware(
dateparser.parse(review.get('date_requested')))
date_due = timezone.make_aware(dateparser.parse(
review.get('date_due')))
date_complete = timezone.make_aware(
dateparser.parse(review.get('date_complete'))) if review.get(
'date_complete') else None
date_confirmed = timezone.make_aware(
dateparser.parse(review.get('date_confirmed'))) if review.get(
'date_confirmed') else None
# If the review was declined, setup a date declined date stamp
review.get('declined')
if review.get('declined') == '1':
date_declined = date_confirmed
date_accepted = None
date_complete = date_confirmed
else:
date_accepted = date_confirmed
date_declined = None
new_review = review_models.ReviewAssignment.objects.create(
article=article,
reviewer=reviewer,
review_round=round,
review_type='traditional',
visibility='double-blind',
date_due=date_due,
date_requested=date_requested,
date_complete=date_complete,
date_accepted=date_accepted,
access_code=uuid.uuid4(),
form=form)
if review.get('declined') or review.get('recommendation'):
new_review.is_complete = True
if review.get('recommendation'):
new_review.decision = map_review_recommendation(
review.get('recommendation'))
if review.get('review_file_url'):
filename, mime = shared.fetch_file(base_url,
review.get('review_file_url'),
None,
None,
article,
None,
handle_images=False,
auth_file=auth_file)
extension = os.path.splitext(filename)[1]
review_file = shared.add_file(mime,
extension,
'Reviewer file',
reviewer,
filename,
article,
galley=False)
new_review.review_file = review_file
if review.get('comments'):
filepath = core_files.create_temp_file(review.get('comments'),
'comment.txt')
file = open(filepath, 'r', encoding="utf-8")
comment_file = core_files.save_file_to_article(
file,
article,
article.owner,
label='Review Comments',
save=False)
new_review.review_file = comment_file
new_review.save()
# Get MS File
ms_file = get_ojs_file(base_url, article_dict.get('manuscript_file_url'),
article, auth_file, 'MS File')
article.manuscript_files.add(ms_file)
# Get RV File
rv_file = get_ojs_file(base_url, article_dict.get('review_file_url'),
article, auth_file, 'RV File')
round.review_files.add(rv_file)
# Get Supp Files
if article_dict.get('supp_files'):
for file in article_dict.get('supp_files'):
file = get_ojs_file(base_url, file.get('url'), article, auth_file,
file.get('title'))
article.data_figure_files.add(file)
article.save()
round.save()
return article
def send_crossref_deposit(server, identifier):
# todo: work out whether this is acceptance or publication
# if it's acceptance, then we use "0" for volume and issue
# if publication, then use real values
# the code here is for acceptance
from utils import setting_handler
article = identifier.article
error = False
template_context = {
'batch_id':
uuid4(),
'timestamp':
int(
round((datetime.datetime.now() -
datetime.datetime(1970, 1, 1)).total_seconds())),
'depositor_name':
setting_handler.get_setting(
'Identifiers', 'crossref_name',
identifier.article.journal).processed_value,
'depositor_email':
setting_handler.get_setting(
'Identifiers', 'crossref_email',
identifier.article.journal).processed_value,
'registrant':
setting_handler.get_setting(
'Identifiers', 'crossref_registrant',
identifier.article.journal).processed_value,
'journal_title':
identifier.article.journal.name,
'journal_issn':
identifier.article.journal.issn,
'date_published':
identifier.article.date_published,
'issue':
identifier.article.issue,
'article_title':
'{0}{1}{2}'.format(
identifier.article.title,
' ' if identifier.article.subtitle is not None else '',
identifier.article.subtitle
if identifier.article.subtitle is not None else ''),
'authors':
identifier.article.authors.all(),
'doi':
identifier.identifier,
'article_url':
identifier.article.url,
'now':
timezone.now(),
}
pdfs = identifier.article.pdfs
if len(pdfs) > 0:
template_context['pdf_url'] = article.pdf_url
if article.license:
template_context["license"] = article.license.url
template = 'identifiers/crossref.xml'
crossref_template = render_to_string(template, template_context)
logger.debug(crossref_template)
util_models.LogEntry.add_entry('Submission',
"Sending request to {1}: {0}".format(
crossref_template, server),
'Info',
target=identifier.article)
response = requests.post(
server,
data=crossref_template.encode('utf-8'),
auth=(setting_handler.get_setting(
'Identifiers', 'crossref_username',
identifier.article.journal).processed_value,
setting_handler.get_setting(
'Identifiers', 'crossref_password',
identifier.article.journal).processed_value),
headers={"Content-Type": "application/vnd.crossref.deposit+xml"})
if response.status_code != 200:
util_models.LogEntry.add_entry('Error',
"Error depositing: {0}. {1}".format(
response.status_code,
response.text),
'Debug',
target=identifier.article)
status = "Error depositing: {code}, {text}".format(
code=response.status_code, text=response.text)
logger.error(status)
logger.error(response.text)
error = True
else:
token = response.json()['message']['batch-id']
status = response.json()['message']['status']
util_models.LogEntry.add_entry('Submission',
"Deposited {0}. Status: {1}".format(
token, status),
'Info',
target=identifier.article)
status = "Status of {} in {}: {}".format(token, identifier.identifier,
status)
logger.info(status)
return status, error
def register_crossref_component(article, xml, supp_file):
from utils import setting_handler
test_url = CROSSREF_TEST_URL
live_url = CROSSREF_LIVE_URL
use_crossref = setting_handler.get_setting('Identifiers', 'use_crossref',
article.journal).processed_value
if not use_crossref:
logger.info(
"[DOI] Not using Crossref DOIs on this journal. Aborting registration."
)
return
test_mode = setting_handler.get_setting('Identifiers', 'crossref_test',
article.journal).processed_value
server = test_url if test_mode else live_url
if test_mode:
util_models.LogEntry.add_entry(
'Submission',
"DOI component registration running in test mode",
'Info',
target=article)
else:
util_models.LogEntry.add_entry(
'Submission',
"DOI component registration running in live mode",
'Info',
target=article)
response = requests.post(
server,
data=xml.encode('utf-8'),
auth=(setting_handler.get_setting('Identifiers', 'crossref_username',
article.journal).processed_value,
setting_handler.get_setting('Identifiers', 'crossref_password',
article.journal).processed_value),
headers={"Content-Type": "application/vnd.crossref.deposit+xml"})
if response.status_code != 200:
util_models.LogEntry.add_entry('Error',
"Error depositing: {0}. {1}".format(
response.status_code,
response.text),
'Debug',
target=article)
logger.error("Error depositing: {}".format(response.status_code))
logger.error(response.text, file=sys.stderr)
else:
token = response.json()['message']['batch-id']
status = response.json()['message']['status']
util_models.LogEntry.add_entry('Submission',
"Deposited {0}. Status: {1}".format(
token, status),
'Info',
target=article)
logger.info("Status of {} in {}: {}".format(
token, '{0}.{1}'.format(article.get_doi(), supp_file.pk), status))
def issn(self):
return setting_handler.get_setting('general',
'journal_issn',
self,
create=False,
fallback='en').value
def edit_metadata(request, article_id):
"""
Allows the Editors and Production Managers to edit an Article's metadata/
:param request: request object
:param article_id: PK of an Article
:return: contextualised django template
"""
article = get_object_or_404(models.Article, pk=article_id)
submission_summary = setting_handler.get_setting(
'general',
'submission_summary',
request.journal,
).processed_value
info_form = forms.ArticleInfo(
instance=article,
submission_summary=submission_summary,
pop_disabled_fields=False,
)
frozen_author, modal = None, None
return_param = request.GET.get('return')
reverse_url = '{0}?return={1}'.format(
reverse('edit_metadata', kwargs={'article_id': article.pk}),
return_param,
)
if request.GET.get('author'):
frozen_author, modal = logic.get_author(request, article)
author_form = forms.EditFrozenAuthor(instance=frozen_author)
else:
author_form = forms.EditFrozenAuthor()
if request.POST:
if 'add_funder' in request.POST:
funder = models.Funder(name=request.POST.get('funder_name',
default=''),
fundref_id=request.POST.get('funder_doi',
default=''),
funding_id=request.POST.get('grant_number',
default=''))
funder.save()
article.funders.add(funder)
article.save()
if 'metadata' in request.POST:
info_form = forms.ArticleInfo(
request.POST,
instance=article,
submission_summary=submission_summary,
pop_disabled_fields=False,
)
if info_form.is_valid():
info_form.save(request=request)
messages.add_message(
request,
messages.SUCCESS,
'Metadata updated.',
)
return redirect(reverse_url)
if 'author' in request.POST:
author_form = forms.EditFrozenAuthor(
request.POST,
instance=frozen_author,
)
if author_form.is_valid():
saved_author = author_form.save()
saved_author.article = article
saved_author.save()
messages.add_message(
request,
messages.SUCCESS,
'Author {0} updated.'.format(saved_author.full_name()),
)
return redirect(reverse_url)
if 'delete' in request.POST:
frozen_author_id = request.POST.get('delete')
frozen_author = get_object_or_404(models.FrozenAuthor,
pk=frozen_author_id,
article=article,
article__journal=request.journal)
frozen_author.delete()
messages.add_message(
request,
messages.SUCCESS,
'Frozen Author deleted.',
)
return redirect(reverse_url)
template = 'submission/edit/metadata.html'
context = {
'article': article,
'info_form': info_form,
'author_form': author_form,
'modal': modal,
'frozen_author': frozen_author,
'return': return_param
}
return render(request, template, context)
def get_setting(self, group_name, setting_name):
return setting_handler.get_setting(group_name,
setting_name,
self,
create=False).processed_value
def publisher(self):
return setting_handler.get_setting('general',
'publisher_name',
self,
create=False,
fallback='en').value
def configure(request):
token = setting_handler.get_setting("plugin",
"doaj_api_token",
journal=request.journal)
journals = {}
push_enabled = False
if request.journal:
push_enabled = setting_handler.get_setting(
"plugin",
"doaj_publish_push",
journal=request.journal,
default=False,
)
else:
for journal in request.press.journals():
enabled = setting_handler.get_setting(
"plugin",
"doaj_publish_push",
journal=journal,
default=False,
)
if enabled:
journals[journal] = True
else:
journals[journal] = False
if token.journal == request.journal:
initial_token = token.value
else:
initial_token = None
token_form = core_forms.EditKey(
key_type=token.setting.types,
value=initial_token or None,
)
if request.POST:
token_form
posted_codes = set(request.POST.getlist("journal_push", []))
posted_token = request.POST.get("value")
if posted_token:
setting_handler.save_setting("plugin",
"doaj_api_token",
journal=request.journal,
value=posted_token)
if request.journal:
#If blank, delete potential override
if not posted_token and token.journal:
token.delete()
if request.journal.code in posted_codes:
setting_handler.save_setting(
"plugin",
"doaj_publish_push",
journal=request.journal,
value=True,
)
else:
push_enabled = setting_handler.get_setting(
"plugin",
"doaj_publish_push",
journal=request.journal,
default=False,
)
if push_enabled:
push_enabled.delete()
else:
for journal in request.press.journals():
if journal.code in posted_codes:
setting_handler.save_setting(
"plugin",
"doaj_publish_push",
journal=journal,
value=True,
)
else:
enabled = setting_handler.get_setting(
"plugin",
"doaj_publish_push",
journal=journal,
default=False,
)
if enabled:
enabled.delete()
return redirect(reverse("doaj_configure"))
template = 'doaj_transporter/configure.html'
context = {
"token_form": token_form,
"token": token,
"journals": journals,
"push_enabled": push_enabled,
}
return render(request, template, context)
def send_email(subject,
to,
html,
journal,
request,
bcc=None,
cc=None,
attachment=None,
replyto=None):
if journal:
from_email = setting_handler.get_setting('email', 'from_address',
journal).value
subject_setting = setting_handler.get_email_subject_setting(
'email_subject', subject, journal)
subject = "[{0}] {1}".format(
journal.code, subject_setting if subject_setting else subject)
html = "{0}<br />{1}".format(html, journal.name)
else:
from_email = request.press.main_contact
if isinstance(to, str):
if settings.DUMMY_EMAIL_DOMAIN in to:
to = []
else:
to = [to]
elif isinstance(to, Iterable):
to = [
email for email in to if not settings.DUMMY_EMAIL_DOMAIN in email
]
if request and request.user and not request.user.is_anonymous():
reply_to = [request.user.email]
full_from_string = "{0} <{1}>".format(request.user.full_name(),
from_email)
else:
reply_to = []
if request:
full_from_string = "{0} <{1}>".format(
sanitize_from(request.site_type.name), from_email)
else:
full_from_string = from_email
if replyto:
reply_to = replyto
msg = EmailMultiAlternatives(subject,
strip_tags(html),
full_from_string,
to,
bcc=bcc,
cc=cc,
reply_to=reply_to)
msg.attach_alternative(html, "text/html")
if request and request.FILES and request.FILES.getlist('attachment'):
for file in request.FILES.getlist('attachment'):
file.open()
msg.attach(file.name, file.read(), file.content_type)
file.close()
return msg.send()
def get_agreement_text(journal):
pub_fees = setting_handler.get_setting('general', 'publication_fees', journal).value
sub_check = setting_handler.get_setting('general', 'submission_checklist', journal).value
copy_notice = setting_handler.get_setting('general', 'copyright_notice', journal).value
return "{0}\n\n{1}\n\n{2}".format(pub_fees, sub_check, copy_notice)
def get_settings_to_edit(group, journal):
review_form_choices = list()
for form in review_models.ReviewForm.objects.filter(journal=journal):
review_form_choices.append([form.pk, form])
if group == 'submission':
settings = [{
'name':
'disable_journal_submission',
'object':
setting_handler.get_setting('general',
'disable_journal_submission', journal)
}, {
'name':
'abstract_required',
'object':
setting_handler.get_setting(
'general',
'abstract_required',
journal,
)
}, {
'name':
'submission_intro_text',
'object':
setting_handler.get_setting('general', 'submission_intro_text',
journal)
}, {
'name':
'copyright_notice',
'object':
setting_handler.get_setting('general', 'copyright_notice', journal)
}, {
'name':
'submission_checklist',
'object':
setting_handler.get_setting('general', 'submission_checklist',
journal)
}, {
'name':
'acceptance_criteria',
'object':
setting_handler.get_setting('general', 'acceptance_criteria',
journal)
}, {
'name':
'publication_fees',
'object':
setting_handler.get_setting('general', 'publication_fees', journal)
}, {
'name':
'editors_for_notification',
'object':
setting_handler.get_setting('general', 'editors_for_notification',
journal),
'choices':
journal.editor_pks()
}, {
'name':
'user_automatically_author',
'object':
setting_handler.get_setting('general', 'user_automatically_author',
journal),
}, {
'name':
'submission_competing_interests',
'object':
setting_handler.get_setting('general',
'submission_competing_interests',
journal),
}, {
'name':
'submission_summary',
'object':
setting_handler.get_setting('general', 'submission_summary',
journal),
}, {
'name':
'limit_manuscript_types',
'object':
setting_handler.get_setting('general', 'limit_manuscript_types',
journal),
}, {
'name':
'accepts_preprint_submissions',
'object':
setting_handler.get_setting('general',
'accepts_preprint_submissions',
journal),
}, {
'name':
'focus_and_scope',
'object':
setting_handler.get_setting('general', 'focus_and_scope', journal),
}, {
'name':
'publication_cycle',
'object':
setting_handler.get_setting('general', 'publication_cycle',
journal),
}, {
'name':
'peer_review_info',
'object':
setting_handler.get_setting('general', 'peer_review_info',
journal),
}, {
'name':
'copyright_submission_label',
'object':
setting_handler.get_setting('general',
'copyright_submission_label', journal)
}]
setting_group = 'general'
elif group == 'review':
settings = [{
'name':
'reviewer_guidelines',
'object':
setting_handler.get_setting('general', 'reviewer_guidelines',
journal),
}, {
'name':
'default_review_visibility',
'object':
setting_handler.get_setting('general', 'default_review_visibility',
journal),
'choices':
review_models.review_visibilty()
}, {
'name':
'review_file_help',
'object':
setting_handler.get_setting('general', 'review_file_help',
journal),
}, {
'name':
'default_review_days',
'object':
setting_handler.get_setting('general', 'default_review_days',
journal),
}, {
'name':
'enable_one_click_access',
'object':
setting_handler.get_setting('general', 'enable_one_click_access',
journal),
}, {
'name':
'draft_decisions',
'object':
setting_handler.get_setting('general', 'draft_decisions', journal),
}, {
'name':
'default_review_form',
'object':
setting_handler.get_setting('general', 'default_review_form',
journal),
'choices':
review_form_choices
}, {
'name':
'reviewer_form_download',
'object':
setting_handler.get_setting('general', 'reviewer_form_download',
journal),
}]
setting_group = 'general'
elif group == 'crossref':
xref_settings = [
'use_crossref', 'crossref_test', 'crossref_username',
'crossref_password', 'crossref_email', 'crossref_name',
'crossref_prefix', 'crossref_registrant', 'doi_display_prefix',
'doi_display_suffix', 'doi_pattern'
]
settings = process_setting_list(xref_settings, 'Identifiers', journal)
setting_group = 'Identifiers'
elif group == 'crosscheck':
xref_settings = ['enable', 'username', 'password']
settings = process_setting_list(xref_settings, 'crosscheck', journal)
setting_group = 'crosscheck'
elif group == 'journal':
journal_settings = [
'journal_name',
'journal_issn',
'journal_theme',
'journal_description',
'enable_editorial_display',
'multi_page_editorial',
'enable_editorial_images',
'main_contact',
'publisher_name',
'publisher_url',
'maintenance_mode',
'maintenance_message',
'auto_signature',
'slack_logging',
'slack_webhook',
'twitter_handle',
'switch_language',
'google_analytics_code',
'keyword_list_page',
]
settings = process_setting_list(journal_settings, 'general', journal)
settings[2]['choices'] = get_theme_list()
setting_group = 'general'
settings.append({
'name':
'from_address',
'object':
setting_handler.get_setting('email', 'from_address', journal),
})
elif group == 'proofing':
proofing_settings = ['max_proofreaders']
settings = process_setting_list(proofing_settings, 'general', journal)
setting_group = 'general'
else:
settings = []
setting_group = None
return settings, setting_group
def import_review_data(article_dict, article, client):
# Add a new review round
round, _ = review_models.ReviewRound.objects.get_or_create(
article=article,
round_number=1,
)
# Check for files at review level
file_for_review_url = article_dict.get("review_file_url")
fetched_file_for_review = client.fetch_file(file_for_review_url)
if fetched_file_for_review:
file_for_review = core_files.save_file_to_article(
fetched_file_for_review,
article,
article.owner,
label="File for Peer-Review",
)
round.review_files.add(file_for_review)
# Attempt to get the default review form
form = setting_handler.get_setting(
'general',
'default_review_form',
article.journal,
).processed_value
if form:
form = review_models.ReviewForm.objects.get(id=form, )
else:
try:
form = review_models.ReviewForm.objects.filter(
journal=article.journal)[0]
except Exception:
form = None
logger.error(
'You must have at least one review form for the journal before'
' importing.')
raise
# Set for avoiding duplicate review files
for review in article_dict.get('reviews'):
reviewer = get_or_create_account(review)
# Parse the dates
date_requested = timezone.make_aware(
dateparser.parse(review.get('date_requested')))
date_due = timezone.make_aware(dateparser.parse(
review.get('date_due')))
date_complete = timezone.make_aware(
dateparser.parse(review.get('date_complete'))) if review.get(
'date_complete') else None
date_confirmed = timezone.make_aware(
dateparser.parse(review.get('date_confirmed'))) if review.get(
'date_confirmed') else None
date_declined = None
review.get('declined')
if review.get('declined') == '1':
date_accepted = None
date_declined = date_confirmed
else:
date_accepted = date_confirmed
review_defaults = dict(review_type='traditional',
visibility='double-blind',
date_due=date_due,
date_requested=date_requested,
date_complete=date_complete,
date_accepted=date_accepted,
date_declined=date_declined,
access_code=uuid.uuid4(),
form=form)
new_review, _ = review_models.ReviewAssignment.objects.get_or_create(
article=article,
reviewer=reviewer,
review_round=round,
defaults=review_defaults,
)
if review.get('declined') or review.get('recommendation'):
new_review.is_complete = True
if review.get('recommendation'):
new_review.decision = REVIEW_RECOMMENDATION[
review['recommendation']]
# Check for files at article level
review_file_url = review.get("review_file_url")
if review_file_url:
fetched_review_file = client.fetch_file(review_file_url)
if fetched_review_file:
review_file = core_files.save_file_to_article(
fetched_review_file,
article,
reviewer,
label="Review File",
)
new_review.review_file = review_file
if review.get('comments'):
handle_review_comment(article, new_review, review.get('comments'),
form)
new_review.save()
# Get MS File
manuscript_file_url = article_dict.get("manuscript_file_url")
manuscript = client.fetch_file(manuscript_file_url, "manuscript")
if manuscript:
ms_file = core_files.save_file_to_article(manuscript,
article,
article.owner,
label="Manuscript")
article.manuscript_files.add(ms_file)
# Get Supp Files
if article_dict.get('supp_files'):
for supp in article_dict.get('supp_files'):
supp = client.fetch_file(supp["url"], supp["title"])
if supp:
ms_file = core_files.save_file_to_article(
supp, article, article.owner, label="Supplementary File")
article.data_figure_files.add(ms_file)
round.review_files.add(ms_file)
article.save()
round.save()
return article
def handle(self, *args, **options):
"""Pulls forward links
:param args: None
:param options: None
:return: None
"""
date = options.get('date', '2000-01-01')
journal_code = options.get('journal_code', None)
if journal_code:
journals = jm.Journal.objects.filter(code=journal_code)
else:
journals = jm.Journal.objects.all()
for journal in journals:
use_crossref = setting_handler.get_setting(
'Identifiers',
'use_crossref',
journal,
).processed_value
if use_crossref:
usr = setting_handler.get_setting(
'Identifiers',
'crossref_username',
journal,
).value
pwd = setting_handler.get_setting(
'Identifiers',
'crossref_password',
journal,
).value
doi = setting_handler.get_setting(
'Identifiers',
'crossref_prefix',
journal,
).value
payload = {
'usr': usr,
'pwd': pwd,
'doi': doi,
'startDate': date,
}
url = 'https://doi.crossref.org/servlet/getForwardLinks?{}'.format(
urlencode(payload))
print(url)
print('Making request.', end='... ')
r = requests.get(url)
print('[ok]')
print('Souping response', end='... ')
soup = BeautifulSoup(r.text, 'lxml')
print('[ok]')
print('Finding forward links', end='... ')
forward_links = soup.find_all('forward_link')
print('[ok]')
print('Looping through links', end='... ')
for link in forward_links:
type = link.doi.get('type')
doi = link.get('doi')
article = sm.Article.get_article(
journal,
'doi',
doi,
)
if article:
if type == 'journal_article':
process_article(link, article)
elif type == 'book_content':
process_book(link, article)
else:
print('Forward link type {} not supported'.format(
type))
else:
print('Article with doi {} not found.'.format(doi))
print(len(forward_links))
def name(self):
try:
return setting_handler.get_setting('general', 'journal_name', self, create=False, fallback='en').value
except IndexError:
self.name = 'Janeway Journal'
return self.name
