class BasePaymentAttributesSchema(ModelSchema):
"""
Attributes
"""
amount = base_fields.Decimal(places=2)
beneficiary_party = base_fields.Nested(BaseBeneficiaryPartySchema)
charges_information = base_fields.Nested(BaseChargesInformationSchema)
debtor_party = base_fields.Nested(BaseDebtorPartySchema)
fx = base_fields.Nested(BaseFXSchema)
sponsor_party = base_fields.Nested(BaseSponsorPartySchema)
class Meta:
model = PaymentAttributes
fields = (
PaymentAttributes.amount.key,
PaymentAttributes.beneficiary_party.key,
PaymentAttributes.charges_information.key,
PaymentAttributes.currency.key,
PaymentAttributes.debtor_party.key,
PaymentAttributes.end_to_end_reference.key,
PaymentAttributes.fx.key,
PaymentAttributes.numeric_reference.key,
PaymentAttributes.payment_id.key,
PaymentAttributes.payment_purpose.key,
PaymentAttributes.payment_scheme.key,
PaymentAttributes.payment_type.key,
PaymentAttributes.processing_date.key,
PaymentAttributes.reference.key,
PaymentAttributes.scheme_payment_sub_type.key,
PaymentAttributes.scheme_payment_type.key,
PaymentAttributes.sponsor_party.key
)
dump_only = (
PaymentAttributes.id.key,
)
class BaseParkSchema(ModelSchema):
location = GeographySerializer(attribute='location')
operating_hours = base_fields.Nested(BaseBusinessHoursSchema)
operator = base_fields.Nested(BaseOperatorSchema)
sponsors = base_fields.Nested(BaseSponsorSchema(many=True))
rides = base_fields.Nested(BaseRideSchema, many=True)
class Meta:
model = Park
sqla_session = db.session
model_converter = GeoConverter
exclude = (Park.is_active.key, )
class BaseTeamMemberSchema(ModelSchema):
team = base_fields.Nested(BaseTeamSchema)
user = base_fields.Nested(BaseUserSchema)
class Meta:
model = TeamMember
fields = (
'team',
'user',
'is_leader',
)
class AdminListPagerSchema(ModelSchema):
total = base_fields.Integer()
rows = base_fields.Nested(AdminSchema(exclude=['password_hash']),
many=True)
class Meta:
pass
class Notice_contentListPagerSchema(Notice_contentSchema):
"""
Notice Content pager schema
"""
total = base_fields.Integer()
rows = base_fields.Nested(Notice_contentSchema, many=True)
class Meta:
pass
class CategoryListPagerSchema(CategorySchema):
"""
Category pager schema
"""
total = base_fields.Integer()
rows = base_fields.Nested(CategorySchema, many=True)
class Meta:
pass
class TransactionSchema(Schema):
"""
Schema for transactions.
"""
id = fields.Str()
version = fields.Str()
operation = fields.Str()
inputs = fields.Nested(InputSchema, many=True)
outputs = fields.Nested(OutputSchema, many=True)
asset = fields.Method('get_assset_id')
metadata = fields.Method('get_metadata_digest')
def get_assset_id(self, obj):
return obj.asset['data']['id']
def get_metadata_digest(self, obj):
return obj.metadata['hash_digest']
class AttachmentsCKeditorUploadSchema(ModelSchema):
uploaded = base_fields.Integer()
fileName = base_fields.String()
url = base_fields.String()
error = base_fields.Nested(CKeditorUploadErrorSchema)
class Meta:
pass
class IrisListPagerSchema(IrisSchema):
"""
IRIS pager schema
"""
total = base_fields.Integer()
rows = base_fields.Nested(IrisSchema, many=True)
class Meta:
pass
class ConfigsListPagerSchema(ModelSchema):
"""
Configs list pager schema
"""
total = base_fields.Integer()
rows = base_fields.Nested(ConfigsSchema, many=True)
class Meta:
pass
class RolesDetailSchema(ModelSchema):
uid = base_fields.Integer()
rids = base_fields.List(base_fields.Integer())
rids_str = base_fields.String()
resources_ids = base_fields.List(base_fields.Integer())
resources_ids_str = base_fields.String()
titles = base_fields.String()
roles = base_fields.Nested(RolesSchema, many=True)
class Meta:
pass
class BaseChargesInformationSchema(ModelSchema):
sender_charges = base_fields.Nested(BaseChargeSchema, many=True)
receiver_charges_amount = base_fields.Decimal(places=2)
class Meta:
model = ChargesInformation
fields = (
ChargesInformation.bearer_code.key,
ChargesInformation.sender_charges.key,
ChargesInformation.receiver_charges_amount.key,
ChargesInformation.receiver_charges_currency.key
)
class DatasetSchema(ModelSchema):
"""
Base dataset schema exposes only the most general fields.
"""
license = base_fields.Nested('LicenseSchema')
organization = base_fields.Nested('OrganizationSchema')
publisher = base_fields.Nested('PublisherSchema')
sources = base_fields.Nested('SourceSchema', many=True)
references = base_fields.Nested('ReferenceSchema', many=True)
contributor = base_fields.Nested('UserSchema')
story_count = base_fields.Method(serialize='count_stories')
class Meta:
model = Dataset
fields = (
# Inner dimensions
Dataset.id.key,
Dataset.created.key,
Dataset.updated.key,
Dataset.stars.key,
# Basic dimensions
Dataset.name.key,
Dataset.title.key,
Dataset.description.key,
Dataset.homepage.key,
Dataset.version.key,
Dataset.category.key,
Dataset.issued_time.key,
Dataset.keywords.key,
Dataset.image.key,
Dataset.temporal.key,
Dataset.spatial.key,
Dataset.access_level.key,
Dataset.copyrights.key,
Dataset.accrual_periodicity.key,
Dataset.specification.key,
Dataset.data_quality.key,
Dataset.data_dictionary.key,
Dataset.language.key,
# Detailed dimensions
'contributor', # Local user
'license',
'organization',
'publisher',
'sources',
'references',
'story_count')
dump_only = (Dataset.id.key, Dataset.created.key, Dataset.updated.key,
Dataset.stars.key, 'contributor', 'license',
'organization', 'publisher', 'sources', 'references',
'story_count')
def count_stories(self, dataset):
assert isinstance(dataset, Dataset)
return dataset.associated_stories_num()
class DetailedSubmissionSchema(CreateSubmissionSchema):
"""
Detailed Submission schema exposes all useful fields.
"""
from app.modules.assets.models import Asset
assets = base_fields.Nested(
'BaseAssetSchema',
exclude=(Asset.submission_guid.key),
many=True,
)
class Meta(CreateSubmissionSchema.Meta):
fields = CreateSubmissionSchema.Meta.fields + ('assets',)
dump_only = CreateSubmissionSchema.Meta.dump_only
class DetailedTeamSchema(BaseTeamSchema):
"""
Detailed team schema exposes all useful fields.
"""
members = base_fields.Nested('BaseTeamMemberSchema',
exclude=(TeamMember.team, ),
many=True)
#members = base_fields.Nested(
# 'BaseTeamMemberSchema',
# exclude=(TeamMember.team.key, ),
# many=True
#)
class Meta(BaseTeamSchema.Meta):
fields = BaseTeamSchema.Meta.fields + (
'members',
'created',
'updated',
)
class BasePaymentSchema(ModelSchema):
"""
Base Payment schema exposes only the most general fields.
"""
attributes = base_fields.Nested(BasePaymentAttributesSchema)
class Meta:
# pylint: disable=missing-docstring
json_module = simplejson
model = Payment
fields = (
'type',
Payment.id.key,
'version',
Payment.organisation_id.key,
Payment.attributes.key
)
dump_only = (
'type',
Payment.id.key,
'version'
)
class BaseRideSchema(ModelSchema):
ride_type = base_fields.Nested(BaseRideTypeSchema)
class Meta:
model = Ride
exclude = (Ride.park.key, Ride.reviews.key)
class RolesListPagerSchema(ModelSchema):
total = base_fields.Integer()
rows = base_fields.Nested(RolesSchema, many=True)
class Meta:
pass
class F14Parameter(Parameters):
payload = base_fields.Nested(schemas.F14Schema())
payload.metadata['location'] = 'json'
class ParkSchema(BaseParkSchema):
rides = base_fields.Nested(BaseRideSchema, many=True)
class BaseUserSchema(ModelSchema):
reviews = base_fields.Nested(ReviewSchema, many=True)
class Meta:
model = User
class ConditionSchema(Schema):
uri = fields.Url()
details = fields.Nested(ConditionDetailsSchema)
class ExampleParameter(Parameters):
payload = base_fields.Nested(schemas.ExampleSchema())
payload.metadata['location'] = 'json'
class StorySchema(ModelSchema):
contributor = base_fields.Nested('UserSchema')
details = base_fields.Method(serialize='dump_story_details',
deserialize='load_story_details')
class Meta(ModelSchema.Meta):
model = Story
dump_only = (
Story.id.key,
Story.created.key,
Story.updated.key,
'contributor',
)
fields = (
Story.id.key,
Story.title.key,
Story.web.key,
Story.description.key,
Story.category.key,
Story.type.key,
Story.stars.key,
Story.keywords.key,
Story.issued_time.key,
'details',
) + dump_only
def load_story_details(self, value):
"""
Load details field into corresponding story schema
"""
if isinstance(value, str):
value = json.loads(value)
story_type = int(value.get('type', StoryType.INVALID))
if story_type != StoryType.INVALID:
schema = story_details_schema.get(story_type)
if schema is not None:
obj = schema.load(value)
if obj.errors:
abort(code=HTTPStatus.BAD_REQUEST, message=str(obj.errors))
return obj.data
return None
def dump_story_details(self, story_obj):
"""
Format story details.
:param story_obj: an instance of Story
:return: detailed Schema or empty
"""
assert isinstance(story_obj, Story)
res = dict()
details_field = story_details_fields.get(story_obj.type)
# TODO: raise meaingful exception
if details_field is not None:
details = getattr(story_obj, details_field)
schema = story_details_schema.get(story_obj.type)
if schema is not None:
res = schema.dump(details)
if res.errors:
abort(code=HTTPStatus.BAD_REQUEST, message=str(res.errors))
return res.data
return res
class AttachmentsListPagerSchema(ModelSchema):
total = base_fields.Integer()
rows = base_fields.Nested(AttachmentsSchema, many=True)
class Meta:
pass
class OutputSchema(Schema):
amount = fields.Number()
public_keys = fields.List(fields.String)
condition = fields.Nested(ConditionSchema)
