class IncidentSchema(Schema):
id = fields.Integer(as_string=True)
description = fields.String()
datetime = fields.DateTime()
county_name = fields.String()
location = fields.Function(lambda obj: to_geojson(obj.location))
shape = fields.Function(lambda obj: to_geojson(obj.shape))
class Meta:
type_ = 'incident'
self_view = 'incidents_detail'
self_view_kwargs = {'id': '<id>'}
model = Incidents
class PersonSchema(Schema):
class Meta:
type_ = 'person'
self_view = 'person_detail'
self_view_kwargs = {'id': '<id>'}
self_view_many = 'person_list'
id = fields.Integer(as_string=True, dump_only=True)
name = fields.String(required=True)
email = fields.Email(load_only=True)
display_name = fields.Function(
lambda obj: "{} <{}>".format(obj.name.upper(), obj.email))
computers = Relationship(
self_view='person_computers',
self_view_kwargs={'id': '<id>'},
related_view='computer_list',
related_view_kwargs={'id': '<id>'},
many=True,
schema='ComputerSchema',
type_='computer',
)
@pre_load
def remove_id_before_deserializing(self, data, **kwargs):
"""
We don't want to allow editing ID on POST / PATCH
Related issues:
https://github.com/AdCombo/flask-combo-jsonapi/issues/34
https://github.com/miLibris/flask-rest-jsonapi/issues/193
"""
if 'id' in data:
del data['id']
return data
class SubstanceSearchResultSchema(Schema):
id = fields.Str(required=True)
identifiers = fields.Raw(required=True)
# the matches will be the fields in which the identifier was found
matches = fields.Function(lambda obj: obj.get_matches(
getInchikey(request.args.get("identifier"))))
score = fields.Function(lambda obj: obj.score_result(
getInchikey(request.args.get("identifier"))))
class Meta:
type_ = "substance_search_results"
self_view_many = "resolved_substance_list"
model = Substance
sqla_session = db.session
load_instance = True
class UserSchema(Schema):
"""Flask-REST-JSONAPI: Logical data abstraction for User model"""
class Meta: # pylint: disable=too-few-public-methods
"""Define the details that come with HTTP Request"""
type_ = 'user'
# Note: For usage of api.user_details see this discussion:
# https://github.com/miLibris/flask-rest-jsonapi/issues/35
self_view = 'api.user_detail'
self_view_kwargs = {'id': '<id>'}
self_view_many = 'api.user_list'
id = fields.Integer(as_string=True, dump_only=True)
email = fields.Email(load_only=True)
password = fields.Str(load_only=True)
first_name = fields.Str()
last_name = fields.Str()
# Extra: a nicely formatted display name
display_name = fields.Function(lambda obj: "{} {} <{}>".format(
obj.first_name.upper(), obj.last_name.upper(), obj.email))
# Extra: a message
a_message = fields.Function(lambda obj: None if obj.confirmed else
'Please check your email to activate your '
'account.')
# profile pic
profile_pic = fields.Str(load_only=True)
profile_pic_filename = fields.Str(load_only=True)
profile_pic_url = fields.Str()
categories = Relationship(self_view='api.user_categories',
self_view_kwargs={'id': '<id>'},
related_view='api.category_list',
related_view_kwargs={'id': '<id>'},
many=True,
schema='CategorySchema',
type_='category')
items = Relationship(self_view='api.user_items',
self_view_kwargs={'id': '<id>'},
related_view='api.item_list',
related_view_kwargs={'id': '<id>'},
many=True,
schema='ItemSchema',
type_='item')
class LciaResultSchema(ResultSchema):
lcia_method = fields.Relationship(
related_url='/{ref_link}',
related_url_kwargs={'ref_link': '<quantity.link>'},
dump_to='lciaMethod')
scenario = fields.Str()
lcia_score = fields.Function(lambda x: x.serialize_result(),
dump_to='lciaScore')
total = fields.Number()
class BaseUser(Schema):
class Meta:
type_ = "user"
id = fields.Function(lambda obj: obj.__LOOKUP_ATTRS__ and getattr(
obj, obj.__LOOKUP_ATTRS__[0]) or obj.id)
beavyId = fields.Integer(attribute="id")
name = fields.String()
active = fields.Boolean()
created_at = fields.DateTime()
class NotificationActorSchema(NormalSchema):
id = fields.Function(lambda o: o.actor.id)
first_name = fields.Function(lambda o: o.actor.first_name)
last_name = fields.Function(lambda o: o.actor.last_name)
public_name = fields.Function(lambda o: o.actor.public_name)
avatar_url = fields.Function(lambda o: o.actor.avatar_url)
thumbnail_image_url = fields.Function(lambda o: o.actor.thumbnail_image_url)
class PersonSchema(Schema):
class Meta:
type_ = 'person'
#self_view = 'person_detail'
#self_view_kwargs = {'id': '<id>'}
self_view_many = 'person_list'
id = fields.Integer(as_string=True, dump_only=True)
name = fields.Str(requried=True, load_only=True)
email = fields.Email(load_only=True)
# birth_date = fields.Date()
display_name = fields.Function(
lambda obj: "{} <{}>".format(obj.name.upper(), obj.email))
class FlowTermination(Schema):
id = fields.Function(lambda x: '(%s, %s, %s)' % (
x.flow.external_ref, x.termination.direction, x.termination))
flow = fields.Relationship(related_url='/{flow_link}',
related_url_kwargs={'flow_link': '<flow.link>'})
direction = fields.Str(attribute='termination.direction')
termination = fields.Str()
parent = fields.Relationship(
related_url='/{parent_link}',
related_url_kwargs={'parent_link': '<parent.link>'})
class Meta:
type_ = 'termination'
strict = True
class ClientSchema(Schema):
class Meta:
type_ = 'client'
self_view = 'client_detail'
self_view_kwargs = {'id': '<id>'}
self_view_many = 'client_list'
id = fields.Integer(as_string=True, dump_only=True)
name = fields.Str(required=True, load_only=True)
display_name = fields.Function(lambda obj: "{}".format(obj.name.upper()))
users = Relationship(self_view='client_users',
self_view_kwargs={'id': '<id>'},
related_view='user_list',
related_view_kwargs={'id': '<id>'},
many=True,
schema='UserSchema',
type_='user')
class ArtistAliasSchema(Schema):
class Meta:
type_ = 'artist_alias'
self_view = 'artist_alias_detail'
self_view_kwargs = {'id': '<id>'}
id = fields.Function(
lambda obj: "{} {}".format(obj.artist_id, obj.alias_name))
artist_id = fields.Integer(load_only=True)
alias_name = fields.String(load_only=True)
artist = Relationship(attribute='artist',
self_view='alias_artist',
self_view_kwargs={'id': '<id>'},
related_view='artist_detail',
related_view_kwargs={'artist_alias_id': '<id>'},
schema='ArtistSchema',
type_='artist')
class PersonSchema(Schema):
class Meta:
type_ = 'personsapi'
#self_view = 'person_detail'
#self_view_kwargs = {'id': '<id>'}
self_view_many = 'person_list'
id = fields.Integer(as_string=True, dump_only=True)
ID = fields.Integer()
#name = fields.Str(requried=True, load_only=True)
name = fields.Str()
age = fields.Integer()
address = fields.Str()
salary = fields.Integer()
display_name = fields.Function(
lambda obj: "{} <{}>".format(obj.name.upper(), obj.age))
class PersonSchema(Schema):
class Meta:
type_ = 'person'
self_view = 'person_detail'
self_view_kwargs = {'id': '<id>'}
self_view_many = 'person_list'
id = fields.Integer(as_string=True, dump_only=True)
name = fields.Str(required=True, load_only=True)
display_name = fields.Function(lambda obj: "{}".format(obj.name.upper()))
tasks = Relationship(self_view='person_tasks',
self_view_kwargs={'id': '<id>'},
related_view='task_list',
related_view_kwargs={'id': '<id>'},
many=True,
schema='TaskSchema',
type_='task')
class CharacterizationSchema(Schema):
id = fields.Function(lambda x: '%s(%s, %s)' %
(x.quantity.external_ref, x.flow.external_ref, x.flow[
'Compartment'][-1]))
flow = fields.Relationship(related_url='/{flow_link}',
related_url_kwargs={'flow_link': '<flow.link>'})
context = fields.List(fields.Str(), attribute='flow.Compartment')
quantity = fields.Relationship(
related_url='/{quantity_link}',
related_url_kwargs={'quantity_link': '<quantity.link>'})
value = fields.Dict(keys=fields.Str(),
values=fields.Decimal(),
attribute='_locations')
class Meta:
type_ = 'characterization'
strict = True
class ExchangeSchema(Schema):
id = fields.Function(lambda x: '%s(%s, %s, %s)' %
(x.process.external_ref, x.flow.external_ref, x.
direction, x.termination))
process = fields.Relationship(
related_url='/{process_link}',
related_url_kwargs={'process_link': '<process.link'})
flow = fields.Relationship(related_url='/{flow_link}',
related_url_kwargs={'flow_link': '<flow.link>'})
direction = fields.Str()
termination = fields.Str()
value = fields.Number()
class Meta:
type_ = 'exchange'
strict = True
class SnippetsSchema(BaseSchema):
id = fields.UUID(dump_only=True)
desktop_redirect = fields.Url(required=True)
desktop_redirect_count = fields.Integer(dump_only=True)
mobile_redirect = fields.Url()
mobile_redirect_count = fields.Integer(dump_only=True)
tablet_redirect = fields.Url()
tablet_redirect_count = fields.Integer(dump_only=True)
short_url = fields.Url()
time_since_creation = fields.Function(
lambda obj: get_time_since_creation(obj),
dump_only=True,
)
class Meta:
type_ = 'snippets'
strict = True
class PostSchema(Schema):
class Meta:
type_ = 'post'
self_view = 'post_detail'
self_view_kwargs = {'post_id': '<id>'}
id = fields.Str(dump_only=True)
title = fields.Str(required=True)
content = fields.Str()
author_name = fields.Function(lambda obj: obj.author.name)
author_id = fields.Int(required=True)
topic = Relationship(related_view='topic_detail',
related_view_kwargs={'topic_id': '<topic.id>'},
type_='topic')
author = Relationship(related_view='author_detail',
related_view_kwargs={'author_id': '<author.id>'},
type_='author')
class UserSchema(Schema):
class Meta:
type_ = 'user'
self_view = 'user_detail'
self_view_kwargs = {'id': '<id>'}
id = fields.Integer(as_string=True, dump_only=True)
first_name = fields.Str(required=True, load_only=True)
last_name = fields.Str(load_only=True)
email = fields.Email(load_only=True)
display_name = fields.Function(lambda obj: "{} {} <{}>".format(
obj.first_name, obj.last_name, obj.email))
client = Relationship(attribute='client',
self_view='user_client',
self_view_kwargs={'id': '<id>'},
related_view='client_detail',
related_view_kwargs={'user_id': '<id>'},
schema='ClientSchema',
type_='client')
class PersonSchema(Schema):
class Meta:
type_ = 'person'
self_view = 'person_detail'
self_view_kwargs = {'id': '<id>'}
self_view_many = 'person_list'
id = fields.Str(dump_only=True)
name = fields.Str(requried=True, load_only=True)
email = fields.Email(load_only=True)
birth_date = fields.Date()
display_name = fields.Function(lambda obj: "{} <{}>".format(obj.name.upper(), obj.email))
computers = Relationship(self_view='person_computers',
self_view_kwargs={'id': '<id>'},
related_view='computer_list',
related_view_kwargs={'id': '<id>'},
many=True,
schema='ComputerSchema',
type_='computer')
class ReferenceExchangeSchema(Schema):
id = fields.Function(lambda x: '%s/reference/%s' %
(x.process.link, x.flow.external_ref))
flow = fields.Relationship(related_url='/{flow_link}',
related_url_kwargs={'flow_link': '<flow.link>'})
direction = fields.Str()
parent = fields.Relationship(
related_url='/{process_link}',
related_url_kwargs={'process_link': '<process.link>'})
'''#for debug
def get_attribute(self, attr, obj, default):
print('Rx g_a | %s, %s, %s' % (attr, obj, default))
k = super(ReferenceExchangeSchema, self).get_attribute(attr, obj, default=default)
print(k)
return k
'''
class Meta:
type_ = 'reference_exchange'
strict = True
class PersonSchema(Schema):
class Meta:
type_ = "person"
self_view = "person_detail"
self_view_kwargs = {"id": "<id>"}
self_view_many = "person_list"
id = fields.Integer(as_string=True, dump_only=True)
name = fields.Str(required=True, load_only=True)
email = fields.Email(load_only=True)
birth_date = fields.Date()
display_name = fields.Function(
lambda obj: f"{obj.name.upper()} <{obj.email}>")
computers = Relationship(
self_view="person_computers",
self_view_kwargs={"id": "<id>"},
related_view="computer_list",
related_view_kwargs={"id": "<id>"},
many=True,
schema="ComputerSchema",
type_="computer",
)
