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