def test_update_record_info(app):
"""Test update of publication information from INSPIRE."""
assert update_record_info(
None) == 'Inspire ID is None' # case where Inspire ID is None
for inspire_id in (
'1311487',
'19999999'): # check both a valid and invalid Inspire ID
assert update_record_info(
inspire_id
) == 'No HEPData submission' # before creation of HEPSubmission object
submission = process_submission_payload(inspire_id=inspire_id,
submitter_id=1,
reviewer={
'name': 'Reviewer',
'email':
'*****@*****.**'
},
uploader={
'name': 'Uploader',
'email':
'*****@*****.**'
},
send_upload_email=False)
# Process the files to create DataSubmission tables in the DB.
base_dir = os.path.dirname(os.path.realpath(__file__))
directory = os.path.join(base_dir, 'test_data/test_submission')
tmp_path = os.path.join(tempfile.mkdtemp(dir=CFG_TMPDIR),
'test_submission')
shutil.copytree(directory, tmp_path)
process_submission_directory(tmp_path,
os.path.join(tmp_path, 'submission.yaml'),
submission.publication_recid)
do_finalise(submission.publication_recid,
force_finalise=True,
convert=False)
if inspire_id == '19999999':
assert update_record_info(inspire_id) == 'Invalid Inspire ID'
else:
# First change the publication information to that of a different record.
different_inspire_record_information, status = get_inspire_record_information(
'1650066')
assert status == 'success'
hep_submission = get_latest_hepsubmission(inspire_id=inspire_id)
assert hep_submission is not None
update_record(hep_submission.publication_recid,
different_inspire_record_information)
# Then can check that the update works and that a further update is not required.
assert update_record_info(inspire_id, send_email=True) == 'Success'
assert update_record_info(
inspire_id
) == 'No update needed' # check case where information already current
unload_submission(submission.publication_recid)
def test_record_update(app):
"""___test_record_update___"""
with app.app_context():
record_information = create_record({'journal_info': 'Phys. Letts', 'title': 'My Journal Paper'})
record = get_record_by_id(record_information['recid'])
assert (record['title'] == 'My Journal Paper')
assert (record['journal_info'] == 'Phys. Letts')
update_record(record_information['recid'], {'journal_info': 'test'})
updated_record = get_record_by_id(record_information['recid'])
assert (updated_record['journal_info'] == 'test')
def test_record_update(app):
"""___test_record_update___"""
with app.app_context():
record_information = create_record({'journal_info': 'Phys. Letts', 'title': 'My Journal Paper'})
record = get_record_by_id(record_information['recid'])
assert (record['title'] == 'My Journal Paper')
assert (record['journal_info'] == 'Phys. Letts')
update_record(record_information['recid'], {'journal_info': 'test'})
updated_record = get_record_by_id(record_information['recid'])
assert (updated_record['journal_info'] == 'test')
def update_file(inspire_id, recid, only_record_information=False, send_tweet=False):
self = Migrator()
output_location = self.prepare_files_for_submission(inspire_id, force_retrieval=True)
if output_location:
updated_record_information = self.retrieve_publication_information(inspire_id)
record_information = update_record(recid, updated_record_information)
if not only_record_information:
try:
recid = self.load_submission(
record_information, output_location, os.path.join(output_location, "submission.yaml"),
update=True)
if recid is not None:
do_finalise(recid, publication_record=record_information,
force_finalise=True, send_tweet=send_tweet, update=True)
except FailedSubmission as fe:
log.error(fe.message)
fe.print_errors()
remove_submission(fe.record_id)
else:
index_record_ids([record_information['recid']])
else:
log.error('Failed to load {0}'.format(inspire_id))
def update_file(inspire_id,
recid,
force=False,
only_record_information=False,
send_tweet=False,
convert=False):
self = Migrator()
output_location, oldsite_last_updated = self.prepare_files_for_submission(
inspire_id, force_retrieval=True)
if output_location:
updated_record_information = self.retrieve_publication_information(
inspire_id)
record_information = update_record(recid,
updated_record_information)
hep_submission = HEPSubmission.query.filter_by(
publication_recid=recid).first()
version_count = HEPSubmission.query.filter_by(
publication_recid=recid).count()
print('Old site last updated {}'.format(str(oldsite_last_updated)))
print('New site last updated {}'.format(
str(hep_submission.last_updated)))
print('Coordinator ID is {}, version count is {}'.format(
hep_submission.coordinator, version_count))
allow_update = hep_submission.last_updated < oldsite_last_updated and \
hep_submission.coordinator == 1 and version_count == 1
if not only_record_information and (allow_update or force):
try:
recid = self.load_submission(record_information,
output_location,
os.path.join(
output_location,
"submission.yaml"),
update=True)
print('Loaded record {}'.format(recid))
if recid is not None:
do_finalise(recid,
publication_record=record_information,
force_finalise=True,
send_tweet=send_tweet,
update=True,
convert=convert)
except FailedSubmission as fe:
log.error(fe.message)
fe.print_errors()
remove_submission(fe.record_id)
elif not only_record_information:
print('Not updating record {}'.format(recid))
else:
index_record_ids([record_information["recid"]])
else:
log.error("Failed to load {0}".format(inspire_id))
def finalise(recid, publication_record=None, force_finalise=False):
commit_message = request.form.get('message')
# Update publication information from INSPIRE record before finalising.
if not publication_record:
record = get_record_by_id(recid)
content, status = get_inspire_record_information(record['inspire_id'])
if status == 'success':
publication_record = update_record(recid, content)
return do_finalise(recid, publication_record=publication_record, force_finalise=force_finalise,
commit_message=commit_message, send_tweet=True)
def update_file(inspire_id,
recid,
force=False,
only_record_information=False,
send_email=False,
send_tweet=False,
convert=False):
self = Migrator()
output_location, oldsite_last_updated = self.prepare_files_for_submission(
inspire_id, force_retrieval=True)
if output_location:
updated_record_information, status = self.retrieve_publication_information(
inspire_id)
if status == 'success':
record_information = update_record(recid,
updated_record_information)
else:
log.error("Failed to retrieve publication information for {0}".
format(inspire_id))
return
hep_submission = HEPSubmission.query.filter_by(
publication_recid=recid).first()
version_count = HEPSubmission.query.filter_by(
publication_recid=recid).count()
print('Old site last updated {}'.format(str(oldsite_last_updated)))
print('New site last updated {}'.format(
str(hep_submission.last_updated)))
print('Coordinator ID is {}, version count is {}'.format(
hep_submission.coordinator, version_count))
allow_update = (hep_submission.last_updated < oldsite_last_updated or force) and \
hep_submission.coordinator == 1 and version_count == 1
if not only_record_information and allow_update:
try:
recid = self.load_submission(record_information,
output_location,
os.path.join(
output_location,
"submission.yaml"),
update=True)
print('Loaded record {}'.format(recid))
if recid is not None:
do_finalise(recid,
publication_record=record_information,
force_finalise=True,
send_tweet=send_tweet,
update=True,
convert=convert)
except FailedSubmission as fe:
log.error(fe.message)
fe.print_errors()
remove_submission(fe.record_id)
elif not only_record_information:
print('Not updating record {}'.format(recid))
else:
index_record_ids([record_information["recid"]])
_cleaned_id = inspire_id.replace("ins", "")
generate_dois_for_submission.delay(
inspire_id=_cleaned_id
) # update metadata stored in DataCite
if send_email:
notify_publication_update(
hep_submission,
record_information) # send email to all participants
else:
log.error("Failed to load {0}".format(inspire_id))
def update_record_info(inspire_id, send_email=False):
"""Update publication information from INSPIRE for a specific record."""
if inspire_id is None:
log.error("Inspire ID is None")
return 'Inspire ID is None'
inspire_id = inspire_id.replace("ins", "")
hep_submission = get_latest_hepsubmission(inspire_id=inspire_id)
if hep_submission is None:
log.warning("Failed to retrieve HEPData submission for Inspire ID {0}".format(inspire_id))
return 'No HEPData submission'
publication_recid = hep_submission.publication_recid
log.info("Updating recid {} with information from Inspire record {}".format(publication_recid, inspire_id))
updated_inspire_record_information, status = get_inspire_record_information(inspire_id)
if status == 'success':
# Also need to update publication information for data records.
data_submissions = DataSubmission.query.filter_by(
publication_recid=publication_recid, version=hep_submission.version
).order_by(DataSubmission.id.asc())
record_ids = [publication_recid] # list of record IDs
for data_submission in data_submissions:
record_ids.append(data_submission.associated_recid)
same_information = {}
for index, recid in enumerate(record_ids):
if index == 0:
updated_record_information = updated_inspire_record_information
else:
# Only update selected keys for data records.
updated_record_information = {
key: updated_inspire_record_information[key] for key in (
'authors', 'creation_date', 'journal_info', 'collaborations'
)
}
record_information = get_record_by_id(recid)
same_information[recid] = True
for key, value in updated_record_information.items():
if key not in record_information or record_information[key] != value:
log.debug('For recid {}, key {} has new value {}'.format(recid, key, value))
same_information[recid] = False
update_record(recid, updated_record_information)
break
log.info('For recid {}, information needs to be updated: {}'.format(recid, str(not(same_information[recid]))))
if all(same for same in same_information.values()):
return 'No update needed'
else:
log.warning("Failed to retrieve publication information for Inspire record {0}".format(inspire_id))
return 'Invalid Inspire ID'
if hep_submission.overall_status == 'finished':
index_record_ids(record_ids) # index for Elasticsearch
push_data_keywords(pub_ids=[recid])
if not TESTING:
generate_dois_for_submission.delay(inspire_id=inspire_id) # update metadata stored in DataCite
if send_email:
record_information = get_record_by_id(publication_recid)
notify_publication_update(hep_submission, record_information) # send email to all participants
return 'Success'