def get_or_create_article(article_dict, journal):
"""Get or create article, looking up by OJS ID or DOI"""
created = False
date_started = timezone.make_aware(
dateparser.parse(article_dict.get('date_submitted')))
doi = article_dict.get("doi")
ojs_id = article_dict["ojs_id"]
if doi and identifiers_models.Identifier.objects.filter(
id_type="doi",
identifier=doi,
article__journal=journal,
).exists():
article = identifiers_models.Identifier.objects.get(
id_type="doi",
identifier=doi,
article__journal=journal,
).article
elif identifiers_models.Identifier.objects.filter(
id_type="ojs_id",
identifier=ojs_id,
article__journal=journal,
).exists():
article = identifiers_models.Identifier.objects.get(
id_type="ojs_id",
identifier=ojs_id,
article__journal=journal,
).article
else:
created = True
article = submission_models.Article(
journal=journal,
title=article_dict.get('title'),
abstract=article_dict.get('abstract'),
language=article_dict.get('language'),
stage=submission_models.STAGE_UNASSIGNED,
is_import=True,
date_submitted=date_started,
)
article.save()
if doi:
identifiers_models.Identifier.objects.create(
id_type="doi",
identifier=doi,
article=article,
)
identifiers_models.Identifier.objects.create(
id_type="ojs_id",
identifier=ojs_id,
article=article,
)
return article, created
def setUp(self):
"""
Setup the test environment.
:return: None
"""
self.journal_one, self.journal_two = self.create_journals()
self.create_roles([
"editor", "author", "reviewer", "proofreader", "production",
"copyeditor", "typesetter", "proofing_manager", "section-editor"
])
self.regular_user = self.create_user("*****@*****.**")
self.regular_user.is_active = True
self.regular_user.save()
self.second_user = self.create_user("*****@*****.**",
["reviewer"],
journal=self.journal_one)
self.second_user.is_active = True
self.second_user.save()
self.admin_user = self.create_user("*****@*****.**")
self.admin_user.is_staff = True
self.admin_user.is_active = True
self.admin_user.save()
self.inactive_user = self.create_user(
"*****@*****.**",
["editor", "author", "proofreader", "production"],
journal=self.journal_one)
self.inactive_user.is_active = False
self.inactive_user.save()
self.editor = self.create_user("*****@*****.**", ["editor"],
journal=self.journal_one)
self.editor.is_active = True
self.editor.save()
self.author = self.create_user("*****@*****.**", ["author"],
journal=self.journal_one)
self.author.is_active = True
self.author.save()
self.proofreader = self.create_user("*****@*****.**",
["proofreader"],
journal=self.journal_one)
self.proofreader.is_active = True
self.proofreader.save()
self.proofreader_two = self.create_user("*****@*****.**",
["proofreader"],
journal=self.journal_one)
self.proofreader_two.is_active = True
self.proofreader_two.save()
self.production = self.create_user("*****@*****.**",
["production"],
journal=self.journal_one)
self.production.is_active = True
self.production.save()
self.copyeditor = self.create_user("*****@*****.**",
["copyeditor"],
journal=self.journal_one)
self.copyeditor.is_active = True
self.copyeditor.save()
self.typesetter = self.create_user("*****@*****.**",
["typesetter"],
journal=self.journal_one)
self.typesetter.is_active = True
self.typesetter.save()
self.other_typesetter = self.create_user(
"*****@*****.**", ["typesetter"],
journal=self.journal_one)
self.other_typesetter.is_active = True
self.other_typesetter.save()
self.proofing_manager = self.create_user(
"*****@*****.**", ["proofing_manager"],
journal=self.journal_one)
self.proofing_manager.is_active = True
self.proofing_manager.save()
self.other_typesetter.is_active = True
self.other_typesetter.save()
self.section_editor = self.create_user("*****@*****.**",
['section-editor'],
journal=self.journal_one)
self.section_editor.is_active = True
self.section_editor.save()
self.second_reviewer = self.create_user(
"*****@*****.**", ['reviewer'],
journal=self.journal_one)
self.second_reviewer.is_active = True
self.second_reviewer.save()
self.public_file = core_models.File(mime_type="A/FILE",
original_filename="blah.txt",
uuid_filename="UUID.txt",
label="A file that is public",
description="Oh yes, it's a file",
owner=self.regular_user,
is_galley=False,
privacy="public")
self.public_file.save()
self.private_file = core_models.File(mime_type="A/FILE",
original_filename="blah.txt",
uuid_filename="UUID.txt",
label="A file that is private",
description="Oh yes, it's a file",
owner=self.regular_user,
is_galley=False,
privacy="owner")
self.private_file.save()
self.article_in_production = submission_models.Article(
owner=self.regular_user,
title="A Test Article",
abstract="An abstract",
stage=submission_models.STAGE_TYPESETTING,
journal_id=self.journal_one.id)
self.article_in_production.save()
self.article_in_production.data_figure_files.add(self.public_file)
self.article_unsubmitted = submission_models.Article(
owner=self.regular_user,
title="A Test Article",
abstract="An abstract",
stage=submission_models.STAGE_UNSUBMITTED,
journal_id=self.journal_one.id)
self.article_unsubmitted.save()
self.article_unassigned = submission_models.Article(
owner=self.regular_user,
title="A Test Article",
abstract="An abstract",
stage=submission_models.STAGE_UNASSIGNED,
journal_id=self.journal_one.id)
self.article_unassigned.save()
self.article_assigned = submission_models.Article(
owner=self.regular_user,
title="A Test Article",
abstract="An abstract",
stage=submission_models.STAGE_ASSIGNED,
journal_id=self.journal_one.id)
self.article_assigned.save()
self.article_under_review = submission_models.Article(
owner=self.regular_user,
title="A Test Article",
abstract="An abstract",
stage=submission_models.STAGE_UNDER_REVIEW,
journal_id=self.journal_one.id)
self.article_under_review.save()
self.article_review_completed = submission_models.Article.objects.create(
owner=self.regular_user,
title="A Test Article",
abstract="An abstract",
stage=submission_models.STAGE_ACCEPTED,
journal_id=self.journal_one.id,
date_accepted=timezone.now())
self.article_author_is_owner = submission_models.Article.objects.create(
owner=self.author,
title="A Test Article",
abstract="An abstract",
stage=submission_models.STAGE_ACCEPTED,
journal_id=self.journal_one.id,
date_accepted=timezone.now())
self.article_author_is_owner.authors.add(self.editor)
self.article_author_is_owner.authors.add(self.author)
self.review_form = review_models.ReviewForm(name="A Form",
slug="A Slug",
intro="i",
thanks="t",
journal=self.journal_one)
self.review_form.save()
self.review_assignment_complete = review_models.ReviewAssignment(
article=self.article_review_completed,
reviewer=self.regular_user,
editor=self.editor,
date_due=datetime.datetime.now(),
form=self.review_form,
is_complete=True,
date_complete=timezone.now())
self.review_assignment_complete.save()
self.review_assignment = review_models.ReviewAssignment(
article=self.article_under_review,
reviewer=self.second_user,
editor=self.editor,
date_due=datetime.datetime.now(),
form=self.review_form)
self.review_assignment.save()
self.review_assignment_not_in_scope = review_models.ReviewAssignment(
article=self.article_in_production,
reviewer=self.regular_user,
editor=self.editor,
date_due=datetime.datetime.now(),
form=self.review_form)
self.review_assignment_not_in_scope.save()
self.article_under_revision = submission_models.Article(
owner=self.regular_user,
title="A Test Article",
abstract="An abstract",
stage=submission_models.STAGE_UNDER_REVISION,
journal_id=self.journal_one.id)
self.article_under_revision.save()
self.article_rejected = submission_models.Article(
owner=self.regular_user,
title="A Test Article",
abstract="An abstract",
stage=submission_models.STAGE_REJECTED,
journal_id=self.journal_one.id)
self.article_rejected.save()
self.article_accepted = submission_models.Article(
owner=self.regular_user,
title="A Test Article",
abstract="An abstract",
stage=submission_models.STAGE_ACCEPTED,
journal_id=self.journal_one.id)
self.article_accepted.save()
self.section_editor_assignment = review_models.EditorAssignment(
article=self.article_assigned,
editor=self.section_editor,
editor_type='section-editor',
notified=True)
self.section_editor_assignment.save()
self.article_editor_copyediting = submission_models.Article(
owner=self.regular_user,
title="A Test Article",
abstract="An abstract",
stage=submission_models.STAGE_EDITOR_COPYEDITING,
journal_id=self.journal_one.id)
self.article_editor_copyediting.save()
self.article_author_copyediting = submission_models.Article(
owner=self.regular_user,
title="A Test Article",
abstract="An abstract",
stage=submission_models.STAGE_AUTHOR_COPYEDITING,
journal_id=self.journal_one.id)
self.article_author_copyediting.save()
self.article_final_copyediting = submission_models.Article(
owner=self.regular_user,
title="A Test Article",
abstract="An abstract",
stage=submission_models.STAGE_FINAL_COPYEDITING,
journal_id=self.journal_one.id)
self.article_final_copyediting.save()
self.article_proofing = submission_models.Article(
owner=self.regular_user,
title="A Test Article",
abstract="An abstract",
stage=submission_models.STAGE_PROOFING,
journal_id=self.journal_one.id)
self.article_proofing.save()
assigned = production_models.ProductionAssignment(
article=self.article_in_production,
production_manager=self.production)
assigned.save()
self.article_published = submission_models.Article(
owner=self.regular_user,
title="A Second Test Article",
abstract="An abstract",
stage=submission_models.STAGE_PUBLISHED,
journal_id=self.journal_one.id)
self.article_published.save()
assigned = production_models.ProductionAssignment(
article=self.article_published, production_manager=self.production)
assigned.save()
self.article_in_production_inactive = submission_models.Article(
owner=self.regular_user,
title="A Test Article",
abstract="An abstract",
stage=submission_models.STAGE_TYPESETTING,
journal_id=self.journal_one.id)
self.article_in_production_inactive.save()
self.assigned = production_models.ProductionAssignment(
article=self.article_in_production_inactive,
production_manager=self.inactive_user)
self.assigned.save()
self.copyedit_assignment = copyediting_models.CopyeditAssignment(
article=self.article_editor_copyediting,
editor=self.editor,
copyeditor=self.copyeditor,
due=timezone.now(),
assigned=timezone.now(),
notified=timezone.now(),
decision='accepted',
date_decided=timezone.now())
self.copyedit_assignment.save()
self.typeset_task = production_models.TypesetTask(
assignment=self.assigned,
typesetter=self.typesetter,
notified=True,
accepted=timezone.now())
self.typeset_task.save()
self.other_typeset_task = production_models.TypesetTask(
assignment=self.assigned,
typesetter=self.other_typesetter,
notified=True,
accepted=timezone.now())
self.other_typeset_task.save()
self.proofing_assignment = proofing_models.ProofingAssignment(
article=self.article_proofing,
proofing_manager=self.proofing_manager,
notified=True)
self.proofing_assignment.save()
self.proofing_assignment.add_new_proofing_round()
self.proofing_task = proofing_models.ProofingTask(
round=self.proofing_assignment.current_proofing_round(),
proofreader=self.proofreader,
notified=True,
due=timezone.now(),
accepted=timezone.now(),
task='sdfsdffs')
self.proofing_task.save()
self.correction_task = proofing_models.TypesetterProofingTask(
proofing_task=self.proofing_task,
typesetter=self.typesetter,
notified=True,
due=timezone.now(),
accepted=timezone.now(),
task='fsddsff')
self.correction_task.save()
self.journal_one.name = 'Journal One'
self.journal_two.name = 'Journal Two'
self.press = press_models.Press.objects.create(name='Press',
domain='localhost',
main_contact='*****@*****.**')
self.press.save()
call_command('sync_journals_to_sites')
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
def create_article_record(dump_name, soup, journal, default_section, section_key):
imported_article, created = models.ImportedArticle.objects.get_or_create(
dump_name=dump_name,
bepress_id=soup.articleid.string,
journal=journal,
)
if created or not imported_article.article:
article = submission_models.Article(is_import=True)
logger.info(
"Importing new article with bepress id %s"
"" % imported_article.bepress_id
)
else:
article = imported_article.article
logger.info(
"Updating article %s (bepress id %s)"
"" % (article.pk, imported_article.bepress_id)
)
article.title = soup.title.string
article.journal = journal
article.abstract = str(soup.abstract.string) if soup.abstract else ''
date_published = getattr(soup, 'publication-date').string
try:
article.date_published = dateutil.parser.parse(date_published)
except Exception as e:
logger.warning("Unable to parse pub datetime %s, trying to extract date...", date_published)
try:
date_published, *_ = date_published.split("T")
article.date_published = dateutil.parser.parse(date_published)
except Exception as e:
logger.warning("No publication date could be parsed")
article.date_published = timezone.now()
if getattr(soup, 'submission-date'):
submission_date = getattr(soup, 'submission-date').string
try:
article.date_submitted = dateutil.parser.parse(submission_date)
except Exception as e:
logger.warning("Unable to parse sub datetime %s, trying to extract date...", date_published)
date_submitted, *_ = date_submitted.split("T")
article.date_submitted = dateutil.parser.parse(date_submitted)
else:
article.date_submitted = article.date_published
article.stage = submission_models.STAGE_PUBLISHED
metadata_section(soup, article, default_section, section_key)
article.save()
metadata_doi(soup, article)
metadata_keywords(soup, article)
metadata_authors(soup, article)
metadata_license(soup, article)
metadata_citation(soup, article)
metadata_pages(soup, article)
metadata_competing_interests(soup, article)
metadata_notes(soup, article)
metadata_publisher_notes(soup, article)
metadata_publisher_name(soup, article)
metadata_peer_reviewed(soup, article)
article.save()
imported_article.article = article
imported_article.save()
return article