class LicenseSchema(StructSchema): _STRUCT_CLS = data_structs.LicenseStruct open_access = fields.Boolean(default=True) title = fields.String() url = fields.URL() version = fields.String() type = fields.String()
class MapLayerSchema(Schema): """ Schema of map layers in UI campaign config """ name = fields.Str(required=True) url = fields.URL(required=True) attribution = fields.Nested(AttributionSchema) presets = fields.List(fields.Str())
class UserSchema(Schema): """User marshmallow schema""" _id = ObjectId() name = fields.Str(required=True, validate=validate.Length( min=1, error="User name cannot be empty.")) surname = fields.Str(required=True, validate=validate.Length( min=1, error="User surname cannot be empty.")) uid = fields.Str(required=True) location = fields.Nested(LocationSchema, required=True) email = fields.Email(required=True) facebook = fields.Str() google = fields.Str() photo = fields.URL() member_since = fields.Str() last_login = fields.Str() points = fields.Int() purchases = fields.Int() metadata = fields.Nested(UserMetadataSchema) @post_load def make_user(self, data): """Deserializes data into a User object""" return User(**data)
class ImportV1DatasetSchema(Schema): # pylint: disable=no-self-use, unused-argument @pre_load def fix_extra(self, data: Dict[str, Any], **kwargs: Any) -> Dict[str, Any]: """ Fix for extra initially beeing exported as a string. """ if isinstance(data.get("extra"), str): data["extra"] = json.loads(data["extra"]) return data table_name = fields.String(required=True) main_dttm_col = fields.String(allow_none=True) description = fields.String(allow_none=True) default_endpoint = fields.String(allow_none=True) offset = fields.Integer() cache_timeout = fields.Integer(allow_none=True) schema = fields.String(allow_none=True) sql = fields.String(allow_none=True) params = fields.Dict(allow_none=True) template_params = fields.Dict(allow_none=True) filter_select_enabled = fields.Boolean() fetch_values_predicate = fields.String(allow_none=True) extra = fields.Dict(allow_none=True) uuid = fields.UUID(required=True) columns = fields.List(fields.Nested(ImportV1ColumnSchema)) metrics = fields.List(fields.Nested(ImportV1MetricSchema)) version = fields.String(required=True) database_uuid = fields.UUID(required=True) data = fields.URL()
class PromptMessageSchema(Schema): text = fields.String(required=True, allow_none=True) media_url = fields.URL(allow_none=True) @post_load def make_prompt_message(self, data, **kwargs): return PromptMessage(**data)
class LinksSchema(ma.SQLAlchemySchema): class Meta: model = Links load_instance = True id = ma.auto_field() long_url = fields.URL() short_postfix = fields.String(validate = validate.Regexp("^[{}]+$".format(digit_set))) count = ma.auto_field() short_link = AbsoluteUrlFor("linksresource", values=dict(short_postfix='<short_postfix>')) @pre_load def pre_process_postfix(self, data, **kwarg): if "short_postfix" in data and not "id" in data: if not match("^[{}]+$".format(digit_set), data['short_postfix']): raise ValidationError("malformed url") id = BaseN.BaseNToDec(data['short_postfix'], digit_set) data['id'] = id return data @pre_dump def pre_dump_postfix(self, link, **kwargs): if not link.short_postfix and link.id: link.short_postfix = BaseN.DecToBaseN(link.id, digit_set) return link
class PartySchema(BaseSchema): """ Party schema mapped onto Party() class attributes """ party_id = fields.Integer(dump_only=True, attribute='id') party_name = fields.String( required=True, validate=[ validate.Length( min=4, error="Party name does not meet minimum length of 4 letters."), validate.Regexp(r'[a-zA-Z]', error="Party name cannot contain number(s).") ]) hq_address = fields.String( required=True, validate=[ validate.Length(min=1, error="Please provide party Headquarters address.") ]) logo_url = fields.URL(required=True) @pre_load def lower_cased(self, data): """return the input names as lower case Args: data (dict): data list to get the input field Returns: dict: input field party name in lower case """ data["party_name"] = data["party_name"].lower() return data
class GithubRepoSchema(Schema): id = fields.Int(required=True) repo_name = fields.Str() full_name = fields.Str() language = fields.Str() description = fields.Str() repo_url = fields.URL()
class EntitySchema(Schema): entity_registry_id = mfields.String(default=None, allow_none=True) registry_id = mfields.String(default=None, allow_none=True) archive_reason = mfields.Dict(allow_none=True) id = mfields.String() name = mfields.String(required=True, allow_none=False) created_at = mfields.String(load_only=True) modified_at = mfields.String(load_only=True) creator = mfields.Dict() custom_fields = mfields.Dict() fields = mfields.Dict(allow_none=False) schema = mfields.Nested("EntitySchemaSchema", allow_none=True) schema_id = mfields.Method("get_schema_id") aliases = mfields.List(mfields.String()) folder_id = mfields.String(required=True, allow_none=True) # schema = mfields.Dict(allow_none=True) # schema # entity # archive_record # mfields # custommfields web_url = mfields.URL() class Meta: unknown = INCLUDE additional = ("id",) def get_schema_id(self, obj): if hasattr(obj, "schema_id") and obj.schema_id: return obj.schema_id elif hasattr(obj, "schema") and obj.schema: return obj.schema["id"]
class MetadataSchemaV1(InvenioRecordMetadataSchemaV1Mixin, DCObjectSchemaV1Mixin, StrictKeysMixin): """Schema for the record metadata.""" ALLOWED_SCHEMAS = ACL_ALLOWED_SCHEMAS PREFERRED_SCHEMA = ACL_PREFERRED_SCHEMA owners = fields.List(fields.Int(), dump_only=True) abstract = MultilingualStringSchemaV1(required=True) description = MultilingualStringSchemaV1(required=True) contributors = SanitizedUnicode(required=False) event = fields.Nested(EventSchemaV1(), required=False) difficulty = SanitizedUnicode(required=True) license = SanitizedUnicode(required=True) formats = fields.Nested(FormatSchemaV1(many=True), many=True, required=False) source = fields.URL() @pre_load def set_owners(self, in_data, **kwargs): if current_user.is_authenticated: in_data['owners'] = [current_user.get_id()] return in_data class Meta: unknown = INCLUDE
class EntrySchema(GenericSchema): category_id = fields.Integer() name = fields.String() author = fields.String() headline = fields.String() description = fields.String() url = fields.URL()
class SCEPPayload(Payload): URL = fields.URL(attribute='url') Name = fields.String(attribute='name') # Subject = fields.Nested() Challenge = fields.String(attribute='challenge') Keysize = fields.Integer(attribute='key_size') CAFingerprint = fields.String(attribute='ca_fingerprint') KeyType = fields.String(attribute='key_type') KeyUsage = EnumField(KeyUsage, attribute='key_usage', by_value=True) # SubjectAltName = fields.Dict(attribute='subject_alt_name') Retries = fields.Integer(attribute='retries') RetryDelay = fields.Integer(attribute='retry_delay') @post_dump(pass_many=False) def wrap_payload_content(self, data: dict) -> dict: """SCEP Payload is silly and double wraps its PayloadContent item.""" inner_content = { 'URL': data.pop('URL', None), 'Name': data.pop('Name'), 'Challenge': data.pop('Challenge'), 'Keysize': data.pop('Keysize'), 'CAFingerprint': data.pop('CAFingerprint'), 'KeyType': data.pop('KeyType'), 'KeyUsage': data.pop('KeyUsage'), 'Retries': data.pop('Retries'), 'RetryDelay': data.pop('RetryDelay'), } data['PayloadContent'] = inner_content return data @post_load def make_payload(self, data: dict) -> models.SCEPPayload: return models.SCEPPayload(**data)
class WebhookSchema(Schema): webhook_url = fields.URL(required=True) webhook_type = fields.Integer(validate=validate.OneOf( Webhook.HOOK_TYPES, error='invalid webhook type')) event_list = fields.List( fields.String(validate=validate.OneOf( action_types.action_map, error='not a valid event type'), ))
class LocationArgs(mm.Schema): class Meta: rh_context = ('location', ) name = fields.String(required=True) room_name_format = fields.String(required=True) map_url_template = fields.URL(schemes={'http', 'https'}, allow_none=True, missing='') @validates('name') def _check_name_unique(self, name): location = self.context['location'] query = Location.query.filter( ~Location.is_deleted, func.lower(Location.name) == name.lower()) if location: query = query.filter(Location.id != location.id) if query.has_rows(): raise ValidationError(_('Name must be unique')) @validates('room_name_format') def _check_room_name_format_placeholders(self, room_name_format): missing = { x for x in ('{building}', '{floor}', '{number}') if x not in room_name_format } if missing: # validated client-side, no i18n needed raise ValidationError('Missing placeholders: {}'.format( ', '.join(missing)))
class StandardUpdatesSchema(Schema): uuid = fields.UUID() identification = fields.Str(example="ISO 9001:2015") publication_date = fields.Date() title = fields.Str() description = fields.Str() link = fields.URL() synchronized = fields.Bool()
class SubappSchema(Schema): subappid = fields.Int(dump_only=True) subappsid = fields.Str(required=True, validate=validate.Length(equal=3)) subappurl = fields.URL(required=False) subappdesc = fields.Str(required=False, validate=validate.Length(min=3, max=255)) createdAt = fields.DateTime(dump_only=True) updatedAt = fields.DateTime(dump_only=True)
class CategorySchema(BaseSchema): __model__ = Category id = fields.Integer() name = fields.String(required=True, allow_none=False) image_url = fields.URL(required=False, allow_none=True) folders = fields.Nested(FolderSchema, many=True, dump_only=True)
class SocialSchema(Schema): email = fields.Email() fan_page = fields.Str() instagram = fields.Str() line = fields.Str() telephone = fields.Str() website = fields.URL() youtube = fields.Str()
class ScrapeRequestSchema(Schema): app_name = fields.Str(required=True) app_store_url = fields.URL(required=True) @validates('app_store_url') def validate_app_store_url(self, value): if not value.startswith(u'https://itunes.apple.com/'): raise ValidationError(u'only itunes URLs are allowed')
class VmCustomFieldsSchema(Schema): cf_itsop = fields.Str(allow_none=True) cf_itsop_url = fields.URL(allow_none=True) cf_sync_key = fields.UUID(allow_none=True) @post_load def make_custom_fields(self, data, **kwargs): return VmCustomFields(**data)
class PeerSchema(NETunnelSchema): id = fields.Integer() name = fields.String(required=True) target_netunnel_url = fields.URL(required=True) auth_data = fields.Dict(required=True, keys=fields.String(), values=fields.String()) static_tunnels = fields.List(fields.Nested(StaticTunnelSchema))
class RespiratorQueryArgsSchema(Schema): url = fields.URL(required=False, metadata={"description": "Respirator Site URL"}) class Meta: # This is needed otherwise the schema validation will # fail with the pagination parameters unknown = EXCLUDE
class WordCountSchema(Schema): '''Serialize json''' word = fields.String(required=True, validate=validate.Regexp('^[a-zA-Z0-9]+$', 0,'Word must be alphanumeric')) url = fields.URL(required=True, relative=False, require_tld=False) #check without . @post_load def create_object(self, data): return WordCountModel(**data)
class ClusterSchema(Schema): id = fields.Int() name = fields.Str(required=True, validate=validate.Length(min=1, max=100)) url = fields.URL() @post_load def make_cluster(self, data, **kwargs): return Cluster(**data)
class LaunchSchema(Schema): launch_id = fields.Integer(attribute="id") title = fields.String() description = fields.String() version = fields.String() action_title = fields.String() action = fields.String() launch_image_url = fields.URL()
class PublishSchema(Schema): regex_for_published_date = r"Jan?|Feb?|Mar?|Apr?|May|Jun?|Jul?|Aug?|Sep?|Oct?|Nov?|Dec?\s+\d{1,2}" regex_for_path = r"^(.+)\/([^/]+)$" user_schema = UserSchema() type_of = fields.Str( required=True, allow_none=False, ) id = fields.Int( required=True, allow_none=False, ) title = fields.Str(required=True, allow_none=False) description = fields.Str(required=True, allow_none=False) readable_publish_date = fields.Str( required=True, allow_none=False, validate=validate.Regexp(regex_for_published_date)) slug = fields.Str( required=True, allow_none=False, ) path = fields.Str(required=True, allow_none=False, validate=validate.Regexp(regex_for_path)) url = fields.Str( required=True, allow_none=False, validate=validate.URL(error="Not a valid URL for url field")) comments_count = fields.Int(required=True, allow_none=False) positive_reactions_count = fields.Int(required=True, allow_none=False) collection_id = fields.Int(required=True, allow_none=True) published_timestamp = fields.DateTime(required=True, allow_none=False) cover_image = fields.URL(required=True, allow_none=True) social_image = fields.URL(required=True) canonical_url = fields.URL(required=True) created_at = fields.DateTime(required=True, allow_none=False) edited_at = fields.DateTime(required=True, allow_none=True) crossposted_at = fields.DateTime(required=True, allow_none=True) published_at = fields.DateTime(required=True, allow_none=False) last_comment_at = fields.DateTime(required=True, allow_none=True) tag_list = fields.List(fields.Str, required=True, allow_none=True) tags = fields.Str(required=True, allow_none=True) user = fields.Nested(user_schema)
class RulingSchema(Schema): ruling = fields.Str() ruling_slug = fields.Str() canonical_ruling_graphic = fields.URL() @post_load def make_ruling(self, data): return Ruling(data['ruling'], data['ruling_slug'], data['canonical_ruling_graphic'])
class TokenSchema(SchemaBase): """Schema class to validate tokens.""" api_key = fields.Str(description='The token API key - uniquely identifies the token') name = fields.Str(description='The token name') is_admin = fields.Boolean(description='Is this an admin token?') is_blocked = fields.Boolean(description='Is this token blocked?') token_uses = fields.Int(description='How many times has this token been used?') last_access = fields.DateTime(description='Last time this token was used') callback_url = fields.URL(description='A request will be made to this URL every time the token is used')
class PrimaryIPv4InterfaceSchema(Schema): id = fields.Int() family = fields.Int() url = fields.URL() address = IPv4Interface(required=True) @post_load def make_ipv4(self, data, **kwargs): return IPv4Interface(**data)
class UrlSchema(Schema): """URL schema.""" class Meta: """Meta attributes for the schema.""" unknown = EXCLUDE description = MultilingualStringV2() value = fields.URL(required=True)