class DocumentSchemaV1(StrictKeysMixin):
"""Document schema."""
id = PersistentIdentifier()
metadata = fields.Nested(DocumentMetadataSchemaV1)
links = fields.Dict(dump_only=True)
explanation = fields.Raw(dump_only=True)
class _TestMetadataSchema(Schema):
"""Test schema."""
title = fields.Str()
stars = fields.Integer()
year = fields.Integer()
control_number = PersistentIdentifier()
class OrganisationMetadataSchemaV1(StrictKeysMixin):
"""Schema for the organisation metadata."""
pid = PersistentIdentifier()
code = SanitizedUnicode(required=True)
name = SanitizedUnicode(required=True)
isShared = fields.Boolean()
isDedicated = fields.Boolean()
# When loading, if $schema is not provided, it's retrieved by
# Record.schema property.
schema = GenFunction(load_only=True,
attribute="$schema",
data_key="$schema",
deserialize=schema_from_organisation)
permissions = fields.Dict(dump_only=True)
@pre_dump
def add_permissions(self, item):
"""Add permissions to record.
:param item: Dict representing the record.
:returns: Modified dict.
"""
item['permissions'] = {
'read': OrganisationPermission.read(current_user, item),
'update': OrganisationPermission.update(current_user, item),
'delete': OrganisationPermission.delete(current_user, item)
}
return item
class LomSchemaV1(StrictKeysMixin):
"""Lom schema."""
metadata = fields.Nested(LomMetadataSchemaV1)
created = fields.Str(dump_only=True)
updated = fields.Str(dump_only=True)
id = PersistentIdentifier()
class SourceDataSchema(Schema):
id = PersistentIdentifier()
identifiers = fields.Nested(IdentifierSchema, many=True)
# TODO: title y name, son lo mismo?, parece que si, analizar
title = fields.Str(allow_none=False)
name = fields.Str(allow_none=False)
# en issn.org, el campo name, es multiple, pero es mejor usar la llave aliases,
# para todos los diferentes nombres con que es conocida la fuente.
aliases = fields.List(SanitizedUnicode(), many=True)
source_type = fields.Str(allow_none=False)
source_status = fields.Str(allow_none=True)
repository_status = fields.Str(allow_none=True)
source_system = fields.Str()
description = fields.Str()
organizations = fields.Nested(OrganizationDataSchema,
many=True,
unknown=INCLUDE)
classifications = fields.Nested(ClasificationDataSchema,
many=True,
unknown=INCLUDE)
_save_info = fields.Nested(SavingInfoSchema, many=False, unknown=INCLUDE)
_save_info_updated = DateString()
class CustomFieldSchema(schema_to_use):
"""Test schema."""
if marshmallow_version[0] >= 3:
class Meta:
"""."""
unknown = EXCLUDE
date_string_field = DateString(attribute='date_string_field')
sanitized_html_field = SanitizedHTML(attribute='sanitized_html_field')
sanitized_unicode_field = SanitizedUnicode(
attribute='sanitized_unicode_field')
trimmed_string_field = TrimmedString(attribute='trimmed_string_field')
gen_function_field = GenFunction(
lambda o: 'serialize_gen_function_field',
lambda o: 'deserialize_gen_function_field',
)
gen_method_field = GenMethod('serialize_gen_method_field',
'deserialize_gen_method_field')
persistent_identifier_field = PersistentIdentifier()
def serialize_gen_method_field(self, obj):
"""Serialize a value for the GenMethod field."""
return 'serialize_gen_method_field'
def deserialize_gen_method_field(self, value):
"""Deserialize a value for the GenMethod field."""
return 'deserialize_gen_method_field'
class SeriesSchemaV1(RecordMetadataSchemaJSONV1):
"""Series schema."""
class Meta:
"""Meta attributes for the schema."""
unknown = EXCLUDE
abbreviated_title = fields.Str()
abstract = fields.Str()
access_urls = fields.Nested(AccessUrlSchema, many=True)
alternative_titles = fields.Nested(AlternativeTitleSchema, many=True)
authors = fields.List(fields.Str())
created_by = fields.Nested(ChangedBySchema)
edition = fields.Str()
identifiers = fields.Nested(IdentifierSchema, many=True)
internal_notes = fields.Nested(InternalNoteSchema, many=True)
isbn = fields.List(fields.Str())
issn = fields.Str()
languages = fields.List(fields.Str())
mode_of_issuance = fields.Str(required=True)
note = fields.Str()
pid = PersistentIdentifier()
publisher = fields.Str()
title = fields.Str(required=True)
updated_by = fields.Nested(ChangedBySchema)
urls = fields.Nested(UrlSchema, many=True)
@pre_load
def set_changed_by(self, data, **kwargs):
"""Automatically set `created_by` and `updated_by`."""
record = self.context.get("record")
return set_changed_by(data, record)
class AuthorSchemaV1(StrictKeysMixin):
"""Author schema."""
#_oai = Nested(OaiSchemaV1)
metadata = fields.Nested(AuthorMetadataSchemaV1)
created = fields.Str(dump_only=True)
updated = fields.Str(dump_only=True)
id = PersistentIdentifier()
class DocumentRequestSchemaV1(RecordMetadataSchemaJSONV1):
"""Document Request schema."""
class Meta:
"""Meta attributes for the schema."""
unknown = EXCLUDE
authors = SanitizedHTML()
document_pid = SanitizedHTML()
edition = SanitizedHTML()
isbn = SanitizedHTML()
issn = SanitizedHTML()
issue = SanitizedHTML()
journal_title = SanitizedHTML()
medium = fields.Str(required=True)
note = SanitizedHTML()
page = SanitizedHTML()
patron_pid = fields.Str(required=True, validate=validate_patron)
payment_info = fields.Str()
payment_method = fields.Str()
physical_item_provider = fields.Nested(PhysicalItemProviderSchema)
pid = PersistentIdentifier()
publication_year = fields.Int()
request_type = fields.Str(required=True)
standard_number = SanitizedHTML()
title = SanitizedHTML(required=True)
volume = SanitizedHTML()
class MetadataSchemaBaseV1(StrictKeysMixin):
"""Schema for the record metadata."""
id = PersistentIdentifier()
identifiers = Nested(IdentifierSchemaV1, many=True, required=True)
name = SanitizedUnicode(required=True, validate=validate.Length(min=3))
status = SanitizedUnicode()
aliases = fields.List(SanitizedUnicode(), many=True)
acronyms = fields.List(SanitizedUnicode(), many=True)
types = fields.List(SanitizedUnicode(), many=True)
wikipedia_url = fields.Url()
email_address = fields.Email()
ip_addresses = fields.List(SanitizedUnicode(), many=True)
established = fields.Integer()
onei_registry = fields.Integer()
exportable = fields.Bool()
links = fields.List(fields.Url(), many=True)
labels = Nested(LabelSchemaV1, many=True)
relationships = Nested(RelationSchemaV1, many=True)
addresses = Nested(AddressSchemaV1, many=True)
redirect = IdentifierSchemaV1()
_schema = GenFunction(
attribute="$schema",
data_key="$schema",
deserialize=schema_from_context, # to be added only when loading
)
class LoanSchemaV1(RecordMetadataSchemaJSONV1):
"""Loan schema."""
class Meta:
"""Meta attributes for the schema."""
from marshmallow import EXCLUDE
unknown = EXCLUDE
def get_pid_field(self):
"""Return loan PID field name."""
return "pid"
cancel_reason = fields.Str()
document_pid = fields.Str()
end_date = DateString()
extension_count = fields.Integer()
item_pid = fields.Nested(LoanItemPIDSchemaV1)
patron_pid = fields.Str(required=True)
pid = PersistentIdentifier()
pickup_location_pid = fields.Str()
request_expire_date = DateString()
request_start_date = DateString()
start_date = DateString()
transaction_date = DateTimeString(missing=arrow.utcnow().isoformat())
transaction_location_pid = fields.Str(required=True)
transaction_user_pid = fields.Str(required=True)
@validates("transaction_location_pid")
def validate_transaction_location_pid(self, value, **kwargs):
"""Validate transaction_location_pid field."""
transaction_location_is_valid = current_app.config[
"CIRCULATION_TRANSACTION_LOCATION_VALIDATOR"]
if not transaction_location_is_valid(value):
raise ValidationError(
_("The loan `transaction_location_pid` is not valid."),
field_names=["transaction_location_pid"],
)
@validates("transaction_user_pid")
def validate_transaction_user_pid(self, value, **kwargs):
"""Validate transaction_user_pid field."""
transaction_user_is_valid = current_app.config[
"CIRCULATION_TRANSACTION_USER_VALIDATOR"]
if not transaction_user_is_valid(value):
raise ValidationError(
_("The loan `transaction_user_pid` is not valid."),
field_names=["transaction_user_pid"],
)
@post_load
def postload_fields(self, data, **kwargs):
"""Post-load record fields update."""
record = self.context.get("record")
if record:
record.update(data)
return record
else:
return data
class InstitutionSchemaV1(StrictKeysMixin):
"""Institution schema."""
metadata = fields.Nested(InstitutionMetadataSchemaV1)
created = fields.Str(dump_only=True)
updated = fields.Str(dump_only=True)
links = fields.Dict(dump_only=True)
id = PersistentIdentifier()
class MetadataSchemaV1(StrictKeysMixin):
"""Schema for the record metadata."""
{{ cookiecutter.datamodel_pid_name }} = PersistentIdentifier()
title = SanitizedUnicode(required=True, validate=validate.Length(min=3))
keywords = fields.List(SanitizedUnicode(), many=True)
publication_date = DateString()
contributors = Nested(ContributorSchemaV1, many=True, required=True)
class UserSchemaV1(StrictKeysMixin):
"""User schema."""
metadata = fields.Nested(UserMetadataSchemaV1)
created = fields.Str(dump_only=True)
updated = fields.Str(dump_only=True)
links = fields.Dict(dump_only=True)
id = PersistentIdentifier()
class MetadataSchemaV1(SchemaEnforcingMixin, StrictKeysMixin):
"""Schema for the record metadata."""
control_number = PersistentIdentifier()
title = SanitizedUnicode(required=True, validate=validate.Length(min=3))
keywords = fields.List(SanitizedUnicode(), many=True)
publication_date = DateString()
contributors = Nested(ContributorSchemaV1, many=True, required=True)
class SeriesSchemaV1(Schema):
"""Series schema."""
pid = PersistentIdentifier()
mode_of_issuance = fields.Str()
issn = fields.Str()
title = fields.Str()
authors = fields.Str()
class DocumentMetadataSchemaV1(StrictKeysMixin):
"""Schema for the document metadata."""
pid = PersistentIdentifier()
title = SanitizedUnicode(required=True)
abstracts = fields.List(fields.Dict())
authors = fields.Dict(dump_only=True)
institution = fields.Dict(dump_only=True)
class DocumentSchemaV1(StrictKeysMixin):
"""Document schema."""
metadata = fields.Nested(DocumentMetadataSchemaV1)
# created = fields.Str(dump_only=True)
# revision = fields.Integer(dump_only=True)
# updated = fields.Str(dump_only=True)
# links = fields.Dict(dump_only=True)
id = PersistentIdentifier()
class AuthorMetadataSchemaV1(StrictKeysMixin):
"""Schema for the author metadata."""
_oai = Nested(OaiSchemaV1)
id = PersistentIdentifier()
name = SanitizedUnicode(required=True)
organization = SanitizedUnicode(required=False)
class Meta:
unknown = INCLUDE
class SeriesSchemaV1(RecordMetadataSchemaJSONV1):
"""Series schema."""
class Meta:
"""Meta attributes for the schema."""
unknown = EXCLUDE
abbreviated_title = fields.Str()
abstract = fields.Str()
access_urls = fields.Nested(AccessUrlSchema, many=True)
alternative_titles = fields.Nested(AlternativeTitleSchema, many=True)
authors = fields.List(fields.Str())
cover_metadata = fields.Dict()
created_by = fields.Nested(ChangedBySchema)
edition = fields.Str()
extensions = fields.Method('dump_extensions', 'load_extensions')
identifiers = fields.Nested(IdentifierSchema, many=True)
internal_notes = fields.Nested(InternalNoteSchema, many=True)
isbn = fields.List(fields.Str())
issn = fields.Str()
languages = fields.List(fields.Str())
mode_of_issuance = fields.Str(required=True)
note = fields.Str()
pid = PersistentIdentifier()
publication_year = fields.Str()
publisher = fields.Str()
title = fields.Str(required=True)
updated_by = fields.Nested(ChangedBySchema)
urls = fields.Nested(UrlSchema, many=True)
def dump_extensions(self, obj):
"""Dumps the extensions value.
:params obj: content of the object's 'extensions' field
"""
ExtensionSchema = current_app.extensions["invenio-app-ils"] \
.series_metadata_extensions \
.to_schema()
return ExtensionSchema().dump(obj)
def load_extensions(self, value):
"""Loads the 'extensions' field.
:params value: content of the input's 'extensions' field
"""
ExtensionSchema = current_app.extensions["invenio-app-ils"] \
.series_metadata_extensions \
.to_schema()
return ExtensionSchema().load(value)
@pre_load
def preload_fields(self, data, **kwargs):
"""Automatically inject system fields."""
record = self.context.get("record")
data.update(set_changed_by(data, record))
data.update(preserve_cover_metadata(data, record))
return data
class RecordSchema(StrictKeysMixin):
"""Schema for record."""
metadata = fields.Nested(RecordMetadataSchema)
created = fields.Str(dump_only=True)
updated = fields.Str(dump_only=True)
links = fields.Dict(dump_only=True)
id = PersistentIdentifier()
explanation = fields.Raw(dump_only=True)
class ProjectSchemaV1(StrictKeysMixin):
"""Project schema."""
metadata = fields.Nested(ProjectMetadataSchemaV1)
created = fields.Str(dump_only=True)
updated = fields.Str(dump_only=True)
links = fields.Dict(dump_only=True)
id = PersistentIdentifier()
explanation = fields.Raw(dump_only=True)
class SourceSchemaV1(StrictKeysMixin):
"""Source schema."""
metadata = fields.Nested(SourceDataSchemaV1)
created = fields.Str(dump_only=True)
revision = fields.Integer(dump_only=True)
updated = fields.Str(dump_only=True)
links = fields.Dict(dump_only=True)
id = PersistentIdentifier()
class LocationSchemaV1(RecordMetadataSchemaJSONV1):
"""Location schema."""
pid = PersistentIdentifier()
name = fields.Str(required=True)
address = fields.Str()
email = fields.Email()
phone = fields.Str()
notes = fields.Str()
class DepositSchemaV1(StrictKeysMixin):
"""Deposit schema."""
id = PersistentIdentifier()
metadata = fields.Nested(DepositMetadataSchemaV1)
created = fields.Str(dump_only=True)
updated = fields.Str(dump_only=True)
links = fields.Dict(dump_only=True)
explanation = fields.Raw(dump_only=True)
class OrganisationSchemaV1(StrictKeysMixin):
"""organisation schema."""
metadata = fields.Nested(OrganisationMetadataSchemaV1)
created = fields.Str(dump_only=True)
updated = fields.Str(dump_only=True)
links = fields.Dict(dump_only=True)
id = PersistentIdentifier()
explanation = fields.Raw(dump_only=True)
class InternalLocationSchemaV1(Schema):
"""Internal Location schema."""
pid = PersistentIdentifier()
location_pid = fields.Str(required=True)
legacy_id = fields.Str()
name = fields.Str()
physical_location = fields.Str()
notes = fields.Str()
class RecordSchemaV1(ACLRecordSchemaMixinV1, StrictKeysMixin):
"""Record schema."""
metadata = fields.Nested(MetadataSchemaV1)
created = fields.Str(dump_only=True)
revision = fields.Integer(dump_only=True)
updated = fields.Str(dump_only=True)
links = fields.Dict(dump_only=True)
id = PersistentIdentifier()
class LocationSchemaV1(Schema):
"""Location schema."""
pid = PersistentIdentifier()
name = fields.Str(required=True)
email = fields.Email()
address = fields.Str()
phone = fields.Str()
notes = fields.Str()
class RecordSchemaV1(StrictKeysMixin):
"""Record schema."""
metadata = fields.Nested(MetadataSchemaV1)
created = fields.Str(dump_only=True)
revision = fields.Integer(dump_only=True)
updated = fields.Str(dump_only=True)
links = fields.Dict(dump_only=True)
id = PersistentIdentifier()
files = GenFunction(serialize=files_from_context,
deserialize=files_from_context)
