def index_after_commit(sender, changes):
"""Index a record in ES after it was committed to the DB.
This cannot happen in an ``after_record_commit`` receiver from Invenio-Records
because, despite the name, at that point we are not yet sure whether the record
has been really committed to the DB.
"""
for model_instance, change in changes:
if isinstance(model_instance, RecordMetadata):
if change in ("insert", "update", "delete"):
LOGGER.debug(
"Record commited, indexing.",
change=change,
uuid=str(model_instance.id),
)
force_delete = "delete" == change
InspireRecord(
model_instance.json,
model=model_instance).index(force_delete=force_delete)
if "new_record" in model_instance.json:
redirect_references_to_merged_record.delay(
str(model_instance.id))
if (PidStoreBase.get_pid_type_from_schema(
model_instance.json["$schema"]) == "lit"
and "documents" in model_instance.json and
current_app.config["FEATURE_FLAG_ENABLE_FULLTEXT"]):
index_fulltext.delay(str(model_instance.id),
model_instance.version_id)
def get_revisions(endpoint, pid_value):
"""Get revisions of given record"""
try:
Transaction = transaction_class(RecordMetadata)
pid_type = PidStoreBase.get_pid_type_from_endpoint(endpoint)
record = InspireRecord.get_record_by_pid_value(pid_value, pid_type)
revisions = []
for revision in reversed(record.revisions):
transaction_id = revision.model.transaction_id
user = Transaction.query.filter(Transaction.id == transaction_id).one().user
if user:
user_email = user.email
else:
user_email = "system"
revisions.append(
{
"updated": revision.updated,
"revision_id": revision.revision_id,
"user_email": user_email,
"transaction_id": transaction_id,
"rec_uuid": record.id,
}
)
return jsonify(revisions)
except Exception:
raise EditorGetRevisionError
def get_record_and_schema(endpoint, pid_value):
pid_type = PidStoreBase.get_pid_type_from_endpoint(endpoint)
record = InspireRecord.get_record_by_pid_value(pid_value,
pid_type,
original_record=True)
if not check_permissions_for_private_collection_read(
record.get("_collections", [])):
return jsonify(message="Unauthorized", code=403), 403
editor_soft_lock_service = EditorSoftLock(
recid=record["control_number"],
record_version=record.model.version_id,
user_email=current_user.email,
)
editor_lock_payload = editor_soft_lock_service.prepare_editor_lock_api_payload(
)
editor_soft_lock_service.add_lock()
json = {
"record": {
"metadata": record
},
"schema": load_schema(record["$schema"]),
}
json.update(editor_lock_payload)
response = make_response(json)
set_headers_for_record_caching_and_concurrency(response, record)
return response
def get_revisions(endpoint, pid_value):
"""Get revisions of given record"""
try:
Transaction = transaction_class(RecordMetadata)
pid_type = PidStoreBase.get_pid_type_from_endpoint(endpoint)
record = InspireRecord.get_record_by_pid_value(pid_value,
pid_type,
original_record=True)
if not check_permissions_for_private_collection_read(
record.get("_collections", [])):
return jsonify(message="Unauthorized", code=403), 403
revisions = []
for revision in reversed(record.revisions):
transaction_id = revision.model.transaction_id
user = Transaction.query.filter(
Transaction.id == transaction_id).one().user
if user:
user_email = user.email
else:
user_email = "system"
revisions.append({
"updated": revision.updated,
"revision_id": revision.revision_id,
"user_email": user_email,
"transaction_id": transaction_id,
"rec_uuid": record.id,
})
return jsonify(revisions)
except Exception:
raise EditorGetRevisionError
def get_affiliations(data):
affiliations = deepcopy(data.get("affiliations", []))
for affiliation in affiliations:
if "record" in affiliation:
_, affiliation[
"control_number"] = PidStoreBase.get_pid_from_record_uri(
affiliation["record"].get("$ref"))
return affiliations
def get_record_and_schema(endpoint, pid_value):
pid_type = PidStoreBase.get_pid_type_from_endpoint(endpoint)
record = InspireRecord.get_record_by_pid_value(pid_value, pid_type)
return jsonify({
"record": {
"metadata": record
},
"schema": load_schema(record["$schema"])
})
def convert_to_form_data(self, data):
speakers = data.get_value("speakers", [])
for speaker in speakers:
affiliation = get_value(speaker, "affiliations[0]")
if affiliation:
affiliation_value = affiliation.get("value")
affiliation_record = affiliation.get("record")
speaker["affiliation"] = affiliation_value
if affiliation_record:
speaker["affiliation_record"] = affiliation_record
del speaker["affiliations"]
address = data.get_value("address")
if address and "country_code" in address:
address["country"] = country_code_to_name(address["country_code"])
del address["country_code"]
if address and "cities" in address:
address["city"] = get_value(address, "cities[0]")
del address["cities"]
timezone = data.get("timezone")
start_datetime = data.get("start_datetime")
form_start_datetime = iso_utc_to_local_form_datetime(start_datetime, timezone)
end_datetime = data.get("end_datetime")
form_end_datetime = iso_utc_to_local_form_datetime(end_datetime, timezone)
literature_records = [
PidStoreBase.get_pid_from_record_uri(rec["record"]["$ref"])[1]
for rec in data.get("literature_records", [])
]
processed_data = {
"name": data.get_value("title.title", missing),
"additional_info": data.get_value("public_notes[0].value", missing),
"address": address or missing,
"speakers": speakers,
"contacts": data.get_value("contact_details", missing),
"series_name": data.get_value("series[0].name", missing),
"series_number": data.get_value("series[0].number", missing),
"field_of_interest": data.get_value("inspire_categories.term", missing),
"dates": [form_start_datetime, form_end_datetime],
"websites": data.get_value("urls.value", missing),
"material_urls": data.get_value("material_urls", missing),
"join_urls": data.get_value("join_urls", missing),
"captioned": data.get("captioned", missing),
"timezone": timezone,
"abstract": data.get_value("abstract.value", missing),
"keywords": data.get_value("keywords.value", missing),
"literature_records": literature_records or missing,
}
return processed_data
def revert_to_revision(endpoint, pid_value):
"""Revert given record to given revision"""
try:
pid_type = PidStoreBase.get_pid_type_from_endpoint(endpoint)
record = InspireRecord.get_record_by_pid_value(pid_value, pid_type)
revision_id = request.json["revision_id"]
record.revert(revision_id)
db.session.commit()
return jsonify(success=True)
except Exception:
raise EditorRevertToRevisionError
def get_record_and_schema(endpoint, pid_value):
pid_type = PidStoreBase.get_pid_type_from_endpoint(endpoint)
record = InspireRecord.get_record_by_pid_value(
pid_value, pid_type, original_record=True
)
json = {"record": {"metadata": record}, "schema": load_schema(record["$schema"])}
response = make_response(json)
set_headers_for_record_caching_and_concurrency(response, record)
return response
def _get_putcodes_and_recids_iter(self, putcodes):
for putcode, url in self._get_urls_for_putcodes_iter(putcodes):
# Filter out putcodes that do not belong to Inspire.
if INSPIRE_WORK_URL_REGEX.match(url):
recid = PidStoreBase.get_pid_from_record_uri(url)[1]
if not recid:
LOGGER.error(
"OrcidPutcodeGetter: cannot parse recid from url",
url=url,
orcid=self.orcid,
)
continue
yield putcode, recid
def resolve_record_as_root(self, data):
record = data.get("record")
if record is None:
return {}
_, recid = PidStoreBase.get_pid_from_record_uri(record.get("$ref"))
try:
record = InspireRecord.get_record_by_pid_value(pid_value=recid,
pid_type="lit")
except PIDDoesNotExistError:
return {}
titles = record.get("titles")
if not titles:
return {}
data.update(record)
return data
def resolve_experiments_record_as_root(self, data):
record = data.get("record")
if record is None:
return {}
_, recid = PidStoreBase.get_pid_from_record_uri(record.get("$ref"))
try:
experiment = InspireRecord.get_record_by_pid_value(pid_value=recid,
pid_type="exp")
except PIDDoesNotExistError:
return {}
legacy_name = experiment.get("legacy_name")
if not legacy_name:
return {}
data.update(experiment)
return data
def resolve_institutions_record_as_root(self, data):
institution_record = data.get("record")
if institution_record is None:
return {}
_, recid = PidStoreBase.get_pid_from_record_uri(
institution_record.get("$ref"))
try:
conference = InspireRecord.get_record_by_pid_value(pid_value=recid,
pid_type="ins")
except PIDDoesNotExistError:
return {}
legacy_ICN = conference.get("legacy_ICN")
if not legacy_ICN:
return {}
data.update(conference)
return data
def revert_to_revision(endpoint, pid_value):
"""Revert given record to given revision"""
try:
pid_type = PidStoreBase.get_pid_type_from_endpoint(endpoint)
record = InspireRecord.get_record_by_pid_value(pid_value,
pid_type,
original_record=True)
if not check_permissions_for_private_collection_read_write(
record.get("_collections", [])):
return jsonify(message="Unauthorized", code=403), 403
revision_id = request.json["revision_id"]
record.revert(revision_id)
db.session.commit()
return jsonify(success=True)
except Exception:
raise EditorRevertToRevisionError
def get_linked_advisors_when_name_changes(self):
if not self.get("advisors"):
return set()
if (self.get_value("name.preferred_name") !=
self._previous_version.get_value("name.preferred_name")) or (
not self.get_value("name.preferred_name") and
(self.get_value("name.value") !=
self._previous_version.get_value("name.value"))):
advisors_references = self.get_value("advisors.record.$ref")
advisors_pids = [
PidStoreBase.get_pid_from_record_uri(uri)[1]
for uri in advisors_references
]
advisor_uuids = (PersistentIdentifier.query.with_entities(
PersistentIdentifier.object_uuid).filter(
PersistentIdentifier.pid_type == "aut",
PersistentIdentifier.pid_value.in_(advisors_pids),
).all())
return set(str(uuid_list[0]) for uuid_list in advisor_uuids)
return set()
def get_control_number(data):
if "record" not in data:
return missing
_, recid = PidStoreBase.get_pid_from_record_uri(
data["record"].get("$ref"))
return recid