def resolve_relation_type_config(value):
"""Resolve the relation type to config object.
Resolve relation type from string (e.g.: serialization) or int (db value)
to the full config object.
"""
relation_types = current_app.config['PIDRELATIONS_RELATION_TYPES']
if isinstance(value, six.string_types):
try:
obj = next(rt for rt in relation_types if rt.name == value)
except StopIteration:
raise ValueError("Relation name '{0}' is not configured.".format(
value))
elif isinstance(value, int):
try:
obj = next(rt for rt in relation_types if rt.id == value)
except StopIteration:
raise ValueError("Relation ID {0} is not configured.".format(
value))
else:
raise ValueError("Type of value '{0}' is not supported for resolving.".
format(value))
api_class = obj_or_import_string(obj.api)
schema_class = obj_or_import_string(obj.schema)
return obj.__class__(obj.id, obj.name, obj.label, api_class, schema_class)
def indexer_class_for_record_class(self, clz):
endpoint = self.managed_records.by_record_class(clz)
if endpoint:
indexer = endpoint.rest.get('indexer_class',
'invenio_indexer.api.RecordIndexer')
return obj_or_import_string(indexer)
else:
return obj_or_import_string('invenio_indexer.api.RecordIndexer')
def serializer(metadata_prefix):
"""Return etree_dumper instances.
:param metadata_prefix: One of the metadata identifiers configured in
``OAISERVER_METADATA_FORMATS``.
"""
metadataFormats = current_app.config["OAISERVER_METADATA_FORMATS"]
serializer_ = metadataFormats[metadata_prefix]["serializer"]
if isinstance(serializer_, tuple):
return partial(obj_or_import_string(serializer_[0]), **serializer_[1])
return obj_or_import_string(serializer_)
def get_file_object(uuid):
uuid = uuid[4:]
pid_type, pid_value, key = uuid.split(':', maxsplit=2)
pid = PersistentIdentifier.get(pid_type, pid_value)
endpoint = current_drafts.endpoint_for_pid_type(pid_type)
permission_factory = obj_or_import_string(
endpoint.rest['read_permission_factory_imp'])
record = endpoint.record_class.get_record(pid.object_uuid)
request._methodview = SimpleNamespace(search_class=obj_or_import_string(
endpoint.rest.get('search_class', RecordsSearch)))
verify_record_permission(permission_factory, record)
return record.files[key]
def __init__(self, app, entry_point_group=None):
"""Initialize state."""
self.app = app
self.resolver = JSONResolver(entry_point_group=entry_point_group)
self.refresolver_cls = ref_resolver_factory(self.resolver)
self.refresolver_store = None
if (self.app.config.get("RECORDS_REFRESOLVER_CLS")):
self.refresolver_cls = obj_or_import_string(
self.app.config.get("RECORDS_REFRESOLVER_CLS"), )
self.refresolver_store = obj_or_import_string(
self.app.config.get("RECORDS_REFRESOLVER_STORE"))
self.loader_cls = json_loader_factory(self.resolver)
def init_app(self, app):
"""Flask application initialization."""
self.init_config(app)
self.iiif_ext = IIIF(app=app)
# register decorator if configured
decorator_handler = app.config["IIIF_API_DECORATOR_HANDLER"]
if decorator_handler:
decorator_handler_func = obj_or_import_string(decorator_handler)
self.iiif_ext.api_decorator_handler(decorator_handler_func)
# register image opener handler
image_opener = obj_or_import_string(
app.config["IIIF_IMAGE_OPENER_HANDLER"])
self.iiif_ext.uuid_to_image_opener_handler(image_opener)
app.extensions['invenio-iiif'] = self
def record_export(pid_value,
record,
export_format=None,
permissions=None,
is_preview=False):
"""Export page view."""
# Get the configured serializer
exporter = current_app.config.get("APP_RDM_RECORD_EXPORTERS",
{}).get(export_format)
if exporter is None:
abort(404)
serializer = obj_or_import_string(
exporter["serializer"])(options={
"indent": 2,
"sort_keys": True,
})
exported_record = serializer.serialize_object(record.to_dict())
contentType = exporter.get("content-type", export_format)
filename = exporter.get("filename", export_format).format(id=pid_value)
headers = {
'Content-Type': contentType,
'Content-Disposition': f'attachment; filename={filename}'
}
return (exported_record, 200, headers)
def record_export(
record: RecordItem = None,
export_format: str = None,
pid_value: str = None,
is_preview: bool = False,
):
"""Export view for LOM records."""
exporter = current_app.config.get("LOM_RECORD_EXPORTERS", {}).get(export_format)
if exporter is None:
abort(404)
serializer = obj_or_import_string(exporter["serializer"])(
options={
"indent": 2,
"sort_keys": True,
}
)
exported_record = serializer.serialize_object(record.to_dict())
return render_template(
"invenio_records_lom/records/export.html",
export_format=exporter.get("name", export_format),
exported_record=exported_record,
record=LOMUIJSONSerializer().serialize_object_to_dict(record.to_dict()),
permissions=record.has_permissions_to(["update_draft"]),
is_preview=is_preview,
is_draft=record._record.is_draft,
)
def record_export(record=None,
export_format=None,
pid_value=None,
permissions=None):
"""Export page view."""
# Get the configured serializer
exporter = current_app.config.get("APP_RDM_RECORD_EXPORTERS",
{}).get(export_format)
if exporter is None:
abort(404)
serializer = obj_or_import_string(
exporter["serializer"])(options={
"indent": 2,
"sort_keys": True,
})
exported_record = serializer.serialize_object(record.to_dict())
return render_template(
"invenio_app_rdm/records/export.html",
export_format=exporter.get("name", export_format),
exported_record=exported_record,
record=UIJSONSerializer().serialize_object_to_dict(record.to_dict()),
permissions=record.has_permissions_to(['update_draft']),
)
def files_permission_factory(obj, action, pid=None, record=None):
"""Files rest permission factory.
admin: all
moderator: write(organisation only)
read(organisation + as anonymous for other)
anonymous: write(none)
read(record masked, restricted: embargo etc, text never)
"""
# Permission is allowed for all actions.
if current_app.config.get('SONAR_APP_DISABLE_PERMISSION_CHECKS'):
return allow_access
pid_type = None
if pid:
pid_type = pid.pid_type
elif request.view_args.get('pid_value'):
(pid, record) = request.view_args.get('pid_value').data
pid_type = pid.pid_type
files_permission_cls = obj_or_import_string(
current_app.config.get(
'SONAR_APP_FILES_REST_PERMISSION', {}).get(pid_type, FilesPermission))
return files_permission_cls.create_permission(
obj, action, user=None, pid=pid, parent_record=record)
def get_record_object(rec_ref):
"""Fetches an instance of a Record from a certain reference record."""
rec = rec_ref.record
rec_cls = obj_or_import_string(rec.class_name.name, Record)
try:
return rec_cls.get_record(rec.record_uuid)
except NoResultFound:
return None
def index_record(self, created_record):
"""
Index created record in elasticsearch if needed.
"""
if self.index_name:
indexer = obj_or_import_string(self.record_indexer
or RecordIndexer)
return indexer().index(created_record)
def setup_indexer(app):
if app.config[
'INDEXER_RECORD_TO_INDEX'] == invenio_indexer.config.INDEXER_RECORD_TO_INDEX:
app.config[
'INDEXER_RECORD_TO_INDEX'] = 'oarepo_records_draft.record.record_to_index'
# in case it has already been used
app.extensions['invenio-indexer'].record_to_index = \
obj_or_import_string('oarepo_records_draft.record.record_to_index')
def client(self):
client = obj_or_import_string(self.app.config['S3_CLIENT'])
s3_info = current_app.extensions['invenio-s3'].init_s3fs_info
return client(access_key=s3_info['key'],
secret_key=s3_info['secret'],
client_kwargs=s3_info['client_kwargs'],
tenant=self.tenant,
config_kwargs=s3_info['config_kwargs'])
def cleanup_drafts(current_service_imp, seconds=3600):
"""Hard delete of soft deleted drafts.
:param int seconds: numbers of seconds that should pass since the
last update of the draft in order to be hard deleted.
"""
timedelta_param = timedelta(seconds=seconds)
current_service = obj_or_import_string(current_service_imp)
current_service.cleanup_drafts(timedelta_param)
def get_permission_factory(perm_or_factory):
perm_or_factory = obj_or_import_string(perm_or_factory)
def func(*args, **kwargs):
if callable(perm_or_factory):
return perm_or_factory(*args, **kwargs)
return perm_or_factory
return func
def check_create_referenced_object_permissions(self, data):
"""
Check if the caller can create a referenced record from the data. If not,
an exception should be raised.
"""
permission_factory = obj_or_import_string(self.permission_factory)
if permission_factory:
perm = permission_factory(data=data, schema=self)
Permission(perm).require(http_exception=403)
def record_class_from_pid_type(pid_type):
"""Returns a Record class from a given pid_type."""
try:
prefix = current_records_rest.default_endpoint_prefixes[pid_type]
return obj_or_import_string(
current_app.config.get('RECORDS_REST_ENDPOINTS',
{})[prefix]['record_class'])
except KeyError:
return None
def create_referenced_object(self, data):
"""
Create referenced record, mint its pid, index it in elasticsearch if needed.
"""
record_uuid = uuid.uuid4()
minter = self._resolve_minter(self.pid_minter)
minter(record_uuid, data)
record_class = obj_or_import_string(self.record_class)
created_record = record_class.create(data, id_=record_uuid)
self.index_record(created_record)
return created_record
def serialize_created_object(self, created_object):
"""
Serialize the created object into json-friendly representation. The default implementation
checks for self.object_serializer, if it is defined it is applied to created object.
If not, the created object is wrapped by dict().
"""
object_serializer = obj_or_import_string(self.object_serializer)
if object_serializer:
object_data = object_serializer(created_object)
else:
object_data = dict(created_object)
return object_data
def record_permission_factory(record=None, action=None, cls=None):
"""Record permission factory.
:params record: Record against which to check permission.
:params action: Action to check.
:params cls: Class of the permission.
:returns: Permission object.
"""
# Permission is allowed for all actions.
if current_app.config.get('SONAR_APP_DISABLE_PERMISSION_CHECKS'):
return allow_access
# No specific class, the base record permission class is taken.
if not cls:
cls = RecordPermission
cls = obj_or_import_string(cls)
return cls.create_permission(record, action)
def create_document(record_class, data, doi):
record_uuid = uuid.uuid4()
minter = record_class.DOCUMENT_MINTER
if hasattr(minter, '_get_current_object'):
minter = minter._get_current_object()
if isinstance(minter, str):
minter = obj_or_import_string(current_pidstore.minters[minter])
minter(record_uuid, data)
record = record_class.create(data=data, id_=record_uuid)
indexer = record_class.DOCUMENT_INDEXER()
indexer.index(record)
PersistentIdentifier.create(record_class.DOI_PID_TYPE,
doi,
object_type='rec',
object_uuid=record_uuid,
status=PIDStatus.REGISTERED)
db.session.commit()
return Response(status=302, headers={"Location": record.canonical_url})
def init_app(self, app):
"""Flask application initialization."""
# TODO: refactoring app init
self.init_config(app)
self._state = _Sip2State(app)
# Set SIP2 datastore
if not self.datastore:
datastore_factory = obj_or_import_string(
app.config['SIP2_DATASTORE_HANDLER'])
self.datastore = datastore_factory(app)
# Initialize logging
if app.config['SIP2_LOGGING_CONSOLE']:
self.add_console_handler(app)
if app.config['SIP2_LOGGING_FS_LOGFILE']:
self.add_fs_handler(app)
app.extensions['invenio-sip2'] = self
self.app = app
def enrollment_fields(self):
user_field_class = obj_or_import_string(
current_app.config['OAREPO_ENROLLMENT_USER_RESTFUL_SERIALIZATION_CLASS'])
return {
'id': rf.Integer,
'enrollment_type': rf.String,
'external_key': rf.String,
'enrolled_email': rf.String,
'enrolled_user': user_field_class(allow_null=True),
'granting_user': user_field_class,
'revoker': user_field_class(allow_null=True),
'extra_data': rf.Raw,
'state': rf.String,
'start_timestamp': rf.DateTime(dt_format='iso8601'),
'expiration_timestamp': rf.DateTime(dt_format='iso8601'),
'user_attached_timestamp': rf.DateTime(dt_format='iso8601'),
'accepted_timestamp': rf.DateTime(dt_format='iso8601'),
'rejected_timestamp': rf.DateTime(dt_format='iso8601'),
'finalization_timestamp': rf.DateTime(dt_format='iso8601'),
'revocation_timestamp': rf.DateTime(dt_format='iso8601'),
'failure_reason': rf.String,
'actions': rf.List(rf.String)
}
def record_export(record=None,
export_format=None,
pid_value=None,
permissions=None):
"""Export marc21 record page view."""
exporter = current_app.config.get("INVENIO_MARC21_RECORD_EXPORTERS",
{}).get(export_format)
if exporter is None:
abort(404)
serializer = obj_or_import_string(
exporter["serializer"])(options={
"indent": 2,
"sort_keys": True,
})
exported_record = serializer.serialize_object(record.to_dict())
return render_template(
"invenio_records_marc21/records/export.html",
export_format=exporter.get("name", export_format),
exported_record=exported_record,
record=UIJSONSerializer().serialize_object_to_dict(record.to_dict()),
permissions=permissions,
)
def links_factory(self):
return obj_or_import_string(self._links_factory)
def set_records_query_fetcher(self):
"""Get query to retrieve records based on set."""
return obj_or_import_string(
self.app.config["OAISERVER_SET_RECORDS_QUERY_FETCHER"]
)
def list_permission_filter(self):
permission_filter = self.app.config['OAREPO_ENROLLMENT_LIST_PERMISSION_FILTER']
permission_filter = obj_or_import_string(permission_filter)
return permission_filter
def resolve(self, name, default=None):
clz = self.extra.get(name) or self.rest.get(name, default)
if not clz:
return None
return obj_or_import_string(clz)
def test_obj_or_import_string():
"""Test object or string import utility function."""
assert obj_or_import_string(wsgi_proxyfix) == wsgi_proxyfix
assert obj_or_import_string(None, default=wsgi_proxyfix) == wsgi_proxyfix
assert obj_or_import_string(
'invenio_base.wsgi.wsgi_proxyfix') == wsgi_proxyfix
