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)