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