def export_html(request, article, article_files):
with translation.override(settings.LANGUAGE_CODE):
html_file_path = files.create_temp_file(
render_to_string('export/export.html',
context={
'article': article,
'journal': request.journal,
'files': article_files,
}), '{code}-{pk}.html'.format(
code=article.journal.code,
pk=article.pk,
))
zip_file_name = 'export_{}_{}_html.zip'.format(article.journal.code,
article.pk)
zip_path = os.path.join(files.TEMP_DIR, zip_file_name)
zip_file = zipfile.ZipFile(zip_path, mode='w')
zip_file.write(html_file_path, 'article_data.html')
for file in article_files:
zip_file.write(
file.self_article_path(),
file.original_filename,
)
zip_file.close()
return files.serve_temp_file(zip_path, zip_file_name)
def handle_review_comment(article, review_obj, comment, form):
element = form.elements.filter(kind="textarea", name="Review").first()
if element:
soup = BeautifulSoup(comment, "html.parser")
for tag in soup.find_all(["br", "p"]):
tag.replace_with("\n" + tag.text)
comment = soup.text
answer, _ = review_models.ReviewAssignmentAnswer.objects.get_or_create(
assignment=review_obj,
element=element,
)
answer.answer = comment
answer.save()
else:
comment = linebreaksbr(comment)
filepath = core_files.create_temp_file(comment,
'comment-from-ojs.html')
f = open(filepath, 'r')
comment_file = core_files.save_file_to_article(
f,
article,
article.owner,
label='Review Comments',
save=False,
)
review_obj.review_file = comment_file
return review_obj
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')
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