class WidgetSchema(Schema):
id_1 = fields.Integer(as_string=True)
id_2 = fields.Integer(as_string=True)
name = fields.String(required=True)
class DeviceSchema(Schema):
id = fields.Integer()
idRegistration = fields.String()
class UserRoleSchema(Schema):
id = fields.Integer()
description = fields.String()
class WidgetSchema(Schema):
id = fields.Integer(as_string=True)
owner_id = fields.String()
name = fields.String()
class StoredNodeSchema(Schema):
token = fields.Integer()
acl = fields.Dict(keys=fields.UUID(), values=fields.Integer())
network = fields.Dict(keys=fields.String(), values=fields.String())
class TrainPlacesInfoSchema(Schema):
train_id = fields.Integer(required=True)
wagons_info = fields.List(fields.Nested(WagonInfoSchema), required=True)
class MySchema(Schema):
field1 = fields.String()
field2 = fields.Integer()
def test_integer_field_default_set_to_none(self, user):
user.age = None
field = fields.Integer(default=None)
assert field.serialize('age', user) is None
class FileSchema(Schema):
id = fields.Integer(dump_only=True)
name = fields.String()
key = fields.String()
def test_integer_as_string_field(self, user):
field = fields.Integer(as_string=True)
assert field.serialize('age', user) == '42'
def test_integer_field_default(self, user):
user.age = None
field = fields.Integer(default=0)
assert field.serialize('age', user) is None
# missing
assert field.serialize('age', {}) == 0
def test_integer_field(self, user):
field = fields.Integer()
assert field.serialize('age', user) == 42
class EnumeratedValueSchema(Schema):
id = fields.Integer(required=True, validate=Range(min=1))
attribute_id = fields.Integer(data_key='attributeId')
value_i18n = fields.String(data_key='valueI18n')
active = fields.Boolean(required=True)
class PersonAttributeSchema(Schema):
person_id = fields.Integer(data_key='personId', required=True)
attribute_id = fields.Integer(data_key='attributeId', required=True)
enum_value_id = fields.Integer(data_key='enumValueId', allow_none=True)
string_value = fields.String(data_key='stringValue')
class TrainSeatsResponse(Schema):
wagon_seats_info = fields.List(
fields.Nested(WagonSeatsInfoSchema, required=True))
train_id = fields.Integer(required=True)
class VehicleSchema(Schema):
year = fields.Integer(required=True)
class WagonInfoSchema(Schema):
wagon_id = fields.Integer(required=True)
places_num = fields.Integer(required=True)
empty_places = fields.List(fields.Integer(), required=True)
class StudentProfile(Schema):
id = fields.Integer(dump_only=True)
school = fields.String()
sex = fields.String()
age = fields.Integer()
address = fields.String()
famsize = fields.String()
medu = fields.Integer()
fedu = fields.Integer()
mjob = fields.String()
fjob = fields.String()
reason = fields.String()
guardian = fields.String()
traveltime = fields.Integer()
studytime = fields.Integer()
failures = fields.Integer()
schoolsup = fields.String()
famsup = fields.String()
paid = fields.String()
activities = fields.String()
nursery = fields.String()
higher = fields.String()
internet = fields.String()
romantic = fields.String()
famrel = fields.Integer()
freetime = fields.Integer()
goout = fields.Integer()
dalc = fields.Integer()
walc = fields.Integer()
health = fields.Integer()
absences = fields.Integer()
@post_load
def create_student_profile(self, data):
studentprofile = StudentProfile(school=data['school'],
sex=data['sex'],
age=data['age'],
address=data['address'],
famsize=data['famsize'],
medu=data['medu'],
fedu=data['fedu'],
mjob=data['mjob'],
fjob=data['fjob'],
reason=data['reason'],
guardian=data['guardian'],
traveltime=data['traveltime'],
studytime=data['studytime'],
failures=data['failures'],
schoolsup=data['schoolsup'],
famsup=data['famsup'],
paid=data['paid'],
activities=data['activities'],
nursery=data['nursery'],
higher=data['higher'],
internet=data['internet'],
romantic=data['romantic'],
famrel=data['famrel'],
freetime=data['freetime'],
goout=data['goout'],
dalc=data['dalc'],
walc=data['walc'],
health=data['health'],
absences=data['absences'])
return studentprofile
class NoticeParaSchema(Schema):
title = fields.String(50) # 标题
content = fields.String(2000) # 主体
created_at = fields.DateTime() # 时间
id = fields.Integer() # 通知id
class CertificateOutputSchema(LemurOutputSchema):
id = fields.Integer()
external_id = fields.String()
bits = fields.Integer()
body = fields.String()
chain = fields.String()
csr = fields.String()
deleted = fields.Boolean(default=False)
description = fields.String()
issuer = fields.String()
name = fields.String()
dns_provider_id = fields.Integer(required=False, allow_none=True)
date_created = ArrowDateTime()
resolved = fields.Boolean(required=False, allow_none=True)
resolved_cert_id = fields.Integer(required=False, allow_none=True)
rotation = fields.Boolean()
# Note aliasing is the first step in deprecating these fields.
notify = fields.Boolean()
active = fields.Boolean(attribute="notify")
has_private_key = fields.Boolean()
cn = fields.String()
common_name = fields.String(attribute="cn")
distinguished_name = fields.String()
not_after = fields.DateTime()
validity_end = ArrowDateTime(attribute="not_after")
not_before = fields.DateTime()
validity_start = ArrowDateTime(attribute="not_before")
owner = fields.Email()
san = fields.Boolean()
serial = fields.String()
serial_hex = Hex(attribute="serial")
signing_algorithm = fields.String()
key_type = fields.String(allow_none=True)
status = fields.String()
user = fields.Nested(UserNestedOutputSchema)
extensions = fields.Nested(ExtensionSchema)
# associated objects
domains = fields.Nested(DomainNestedOutputSchema, many=True)
destinations = fields.Nested(DestinationNestedOutputSchema, many=True)
notifications = fields.Nested(NotificationNestedOutputSchema, many=True)
replaces = fields.Nested(CertificateNestedOutputSchema, many=True)
authority = fields.Nested(AuthorityNestedOutputSchema)
dns_provider = fields.Nested(DnsProvidersNestedOutputSchema)
roles = fields.Nested(RoleNestedOutputSchema, many=True)
endpoints = fields.Nested(EndpointNestedOutputSchema,
many=True,
missing=[])
replaced_by = fields.Nested(CertificateNestedOutputSchema,
many=True,
attribute="replaced")
rotation_policy = fields.Nested(RotationPolicyNestedOutputSchema)
country = fields.String()
location = fields.String()
state = fields.String()
organization = fields.String()
organizational_unit = fields.String()
@post_dump
def handle_subject_details(self, data):
subject_details = [
"country", "state", "location", "organization",
"organizational_unit"
]
# Remove subject details if authority is CA/Browser Forum compliant. The code will use default set of values in that case.
# If CA/Browser Forum compliance of an authority is unknown (None), it is safe to fallback to default values. Thus below
# condition checks for 'not False' ==> 'True or None'
if data.get("authority"):
is_cab_compliant = data.get("authority").get("isCabCompliant")
if is_cab_compliant is not False:
for field in subject_details:
data.pop(field, None)
# Removing subject fields if None, else it complains in de-serialization
for field in subject_details:
if field in data and data[field] is None:
data.pop(field)
class ItemReportSchema(Schema):
id = fields.Integer(dump_only=True)
class CertificateInputSchema(CertificateCreationSchema):
name = fields.String()
common_name = fields.String(required=True, validate=validators.common_name)
authority = fields.Nested(AssociatedAuthoritySchema, required=True)
validity_start = ArrowDateTime(allow_none=True)
validity_end = ArrowDateTime(allow_none=True)
validity_years = fields.Integer(allow_none=True)
destinations = fields.Nested(AssociatedDestinationSchema,
missing=[],
many=True)
notifications = fields.Nested(AssociatedNotificationSchema,
missing=[],
many=True)
replaces = fields.Nested(AssociatedCertificateSchema,
missing=[],
many=True)
replacements = fields.Nested(AssociatedCertificateSchema,
missing=[],
many=True) # deprecated
roles = fields.Nested(AssociatedRoleSchema, missing=[], many=True)
dns_provider = fields.Nested(AssociatedDnsProviderSchema,
missing=None,
allow_none=True,
required=False)
csr = fields.String(allow_none=True, validate=validators.csr)
key_type = fields.String(validate=validate.OneOf(CERTIFICATE_KEY_TYPES),
missing="ECCPRIME256V1")
notify = fields.Boolean(default=True)
rotation = fields.Boolean()
rotation_policy = fields.Nested(
AssociatedRotationPolicySchema,
missing={"name": "default"},
allow_none=True,
default={"name": "default"},
)
# certificate body fields
organizational_unit = fields.String(missing=lambda: current_app.config.get(
"LEMUR_DEFAULT_ORGANIZATIONAL_UNIT"))
organization = fields.String(
missing=lambda: current_app.config.get("LEMUR_DEFAULT_ORGANIZATION"))
location = fields.String(
missing=lambda: current_app.config.get("LEMUR_DEFAULT_LOCATION"))
country = fields.String(
missing=lambda: current_app.config.get("LEMUR_DEFAULT_COUNTRY"))
state = fields.String(
missing=lambda: current_app.config.get("LEMUR_DEFAULT_STATE"))
extensions = fields.Nested(ExtensionSchema)
@validates_schema
def validate_authority(self, data):
if 'authority' not in data:
raise ValidationError("Missing Authority.")
if isinstance(data["authority"], str):
raise ValidationError("Authority not found.")
if not data["authority"].active:
raise ValidationError("The authority is inactive.", ["authority"])
@validates_schema
def validate_dates(self, data):
validators.dates(data)
@pre_load
def load_data(self, data):
if data.get("replacements"):
data["replaces"] = data[
"replacements"] # TODO remove when field is deprecated
if data.get("csr"):
csr_sans = cert_utils.get_sans_from_csr(data["csr"])
if not data.get("extensions"):
data["extensions"] = {"subAltNames": {"names": []}}
elif not data["extensions"].get("subAltNames"):
data["extensions"]["subAltNames"] = {"names": []}
elif not data["extensions"]["subAltNames"].get("names"):
data["extensions"]["subAltNames"]["names"] = []
data["extensions"]["subAltNames"]["names"] = csr_sans
common_name = cert_utils.get_cn_from_csr(data["csr"])
if common_name:
data["common_name"] = common_name
key_type = cert_utils.get_key_type_from_csr(data["csr"])
if key_type:
data["key_type"] = key_type
# This code will be exercised for certificate import (without CSR)
if data.get("key_type") is None:
if data.get("body"):
data["key_type"] = utils.get_key_type_from_certificate(
data["body"])
else:
data["key_type"] = "ECCPRIME256V1" # default value
return missing.convert_validity_years(data)
class CompanySchema(ma.Schema):
symbol = fields.String(required=True)
name = fields.String(required=True)
sector = fields.String()
employees = fields.Integer()
market = fields.String()
class TicketSearchSchema(Schema):
ticket_id = fields.Integer(missing=None)
usr_email = fields.String(missing=None)
class DebtorSchema(ValidateTypeMixin, Schema):
uri = fields.String(
required=True,
dump_only=True,
format='uri-reference',
description=URI_DESCRIPTION,
example='/debtors/1/',
)
type = fields.Function(
lambda obj: 'Debtor',
required=True,
type='string',
description=TYPE_DESCRIPTION,
example='Debtor',
)
identity = fields.Nested(
DebtorIdentitySchema,
required=True,
dump_only=True,
data_key='identity',
description="The debtor's `DebtorIdentity`.",
example={
'type': 'DebtorIdentity',
'uri': 'swpt:1'
},
)
config = fields.Nested(
DebtorConfigSchema,
required=True,
dump_only=True,
data_key='config',
description="Debtor's `DebtorConfig` settings.",
)
transfers_list = fields.Nested(
ObjectReferenceSchema,
required=True,
dump_only=True,
data_key='transfersList',
description=
"The URI of the debtor's list of pending credit-issuing transfers "
"(`TransfersList`).",
example={'uri': '/debtors/1/transfers/'},
)
create_transfer = fields.Nested(
ObjectReferenceSchema,
required=True,
dump_only=True,
data_key='createTransfer',
description=
'A URI to which the debtor can POST `TransferCreationRequest`s to '
'create new credit-issuing transfers.',
example={'uri': '/debtors/1/transfers/'},
)
save_document = fields.Nested(
ObjectReferenceSchema,
required=True,
dump_only=True,
data_key='saveDocument',
description='A URI to which the debtor can POST documents to be saved.',
example={'uri': '/debtors/1/documents/'},
)
public_info_document = fields.Nested(
ObjectReferenceSchema,
required=True,
dump_only=True,
data_key='publicInfoDocument',
description=
"A URI that redirects to the debtor's public info document.",
example={'uri': '/debtors/1/public'},
)
created_at = fields.DateTime(
required=True,
dump_only=True,
data_key='createdAt',
description='The moment at which the debtor was created.',
)
balance = fields.Int(
required=True,
dump_only=True,
format="int64",
description=
"The total issued amount with a negative sign. Normally, it will be a "
"negative number or a zero. A positive value, although theoretically "
"possible, should be very rare.",
example=-1000000,
)
transfer_note_max_bytes = fields.Integer(
required=True,
dump_only=True,
data_key='noteMaxBytes',
format='int32',
description=
'The maximal number of bytes that transfer notes are allowed to contain when '
'UTF-8 encoded. This will be a non-negative number.',
example=500,
)
optional_config_error = fields.String(
dump_only=True,
data_key='configError',
description=
'When this field is present, this means that for some reason, the current '
'`DebtorConfig` settings can not be applied, or are not effectual anymore. '
'Usually this means that there has been a network communication problem, or a '
'system configuration problem. The value alludes to the cause of the problem.',
example='CONFIGURATION_IS_NOT_EFFECTUAL',
)
optional_account = fields.Nested(
AccountIdentitySchema,
dump_only=True,
data_key='account',
description=
"The `AccountIdentity` of the debtor's account. It uniquely and reliably "
"identifies the debtor's account when it participates in transfers as sender "
"or recipient. When this field is not present, this means that the debtor's "
"account does not have an identity yet, and can not participate "
"in transfers.",
example={
'type': 'AccountIdentity',
'uri': 'swpt:1/0'
},
)
@pre_dump
def process_debtor_instance(self, obj, many):
assert isinstance(obj, Debtor)
obj = copy(obj)
obj.uri = url_for(self.context['Debtor'],
_external=False,
debtorId=obj.debtor_id)
obj.identity = {'uri': f'swpt:{i64_to_u64(obj.debtor_id)}'}
obj.config = obj
obj.transfers_list = {
'uri':
url_for(self.context['TransfersList'],
_external=False,
debtorId=obj.debtor_id)
}
obj.create_transfer = obj.transfers_list
obj.save_document = {
'uri':
url_for(
self.context['SaveDocument'],
_external=False,
debtorId=obj.debtor_id,
)
}
obj.public_info_document = {
'uri':
url_for(self.context['RedirectToDebtorsInfo'],
_external=False,
debtorId=obj.debtor_id)
}
if obj.config_error is not None:
obj.optional_config_error = obj.config_error
try:
obj.optional_account = {
'uri': make_account_uri(obj.debtor_id, obj.account_id)
}
except ValueError:
pass
return obj
class SeatTypeInfoSchema(Schema):
type_name = fields.String(required=True)
num_of_places = fields.Integer(required=True)
cost = fields.Integer(required=True)
class AwsAccountSchema(Schema):
id = fields.Integer()
fancy_name = fields.String()
class WagonSeatsInfoSchema(Schema):
wagon_num = fields.String(required=True)
type_name = fields.String(required=True)
empty_places = fields.List(fields.Integer, required=True)
cost = fields.Integer(required=True)
class RuleTypeSchema(Schema):
id = fields.Integer()
description = fields.String()
class TemperatureDataSchema(Schema):
""" Temperature Data Schema """
temp = fields.Integer(attribute="temp")
feelsLike = fields.Integer(attribute="feels_like")
