class TourSchema(Schema):
id = Integer(required=True)
name = String(required=True)
is_active = Boolean(data_key='isActive', required=True)
description = String(required=True)
city_or_province = String(data_key='cityOrProvince', required=True)
common_address = String(data_key='commonAddress', required=True)
duration = Integer(required=True)
min_size = Integer(data_key='minSize', required=True)
max_size = Integer(data_key='maxSize', required=True)
price_per_participant = Integer(data_key='pricePerParticipant',
required=True)
transportations = Method(serialize='get_transportations')
images = Method(serialize='get_images')
organizer_name = String(data_key='organizerName', required=True)
organizer_email = String(data_key='organizerEmail', required=True)
organizer_phone_number = String(data_key='organizerPhoneNumber',
required=True)
organizer_avatar = String(data_key='organizerAvatar', required=True)
def get_transportations(self, obj):
transportations = obj.transportations
if transportations is not None:
transportations = transportations.split(',')
return transportations
def get_images(self, obj):
images = obj.images
if images is not None:
images = images.split(',')
return images
class UIListSchema(Schema):
"""Schema for dumping extra information in the UI."""
class Meta:
"""."""
unknown = INCLUDE
hits = Method("get_hits")
aggregations = Method("get_aggs")
def get_hits(self, obj_list):
"""Apply hits transformation."""
for obj in obj_list["hits"]["hits"]:
obj[self.context["object_key"]] = self.context[
"object_schema_cls"]().dump(obj)
return obj_list["hits"]
def get_aggs(self, obj_list):
"""Apply aggregations transformation."""
aggs = obj_list.get("aggregations")
if not aggs:
return missing
for name, agg in aggs.items():
vocab = Vocabularies.get_vocabulary(name)
if not vocab:
continue
buckets = agg.get("buckets")
if buckets:
apply_labels(vocab, buckets)
return aggs
class PaperRevisionSchema(mm.SQLAlchemyAutoSchema):
submitter = Nested(UserSchema)
judge = Nested(UserSchema)
spotlight_file = Nested(PaperFileSchema)
files = List(Nested(PaperFileSchema))
state = EnumField(PaperRevisionState)
timeline = PaperRevisionTimelineField()
judgment_comment_html = Function(lambda revision: escape(revision.judgment_comment))
reviewer_data = Method('_get_reviewer_data')
class Meta:
model = PaperRevision
fields = ('id', 'submitted_dt', 'judgment_dt', 'submitter', 'judge', 'spotlight_file', 'files',
'is_last_revision', 'number', 'state', 'timeline', 'judgment_comment', 'judgment_comment_html',
'reviewer_data')
def _get_reviewer_data(self, revision):
if not revision.is_last_revision:
return None
data = dict(revision.get_reviewer_render_data(self.context.get('user')))
review_type_schema = PaperReviewTypeSchema()
for name in ('groups', 'missing_groups', 'reviewed_groups'):
data[name] = [review_type_schema.dump(item.instance) for item in data[name]]
reviews = {}
for key, value in data['reviews'].items():
reviews[orig_string(key.instance.title)] = paper_review_schema.dump(value)
data['reviews'] = reviews
return data
class FileSchema(Schema):
class Meta:
model = File
fields = [
"id", "name", "is_status", "is_reference", "content_type",
"primary", "primary_process_id", "workflow_spec_id", "workflow_id",
"irb_doc_code", "last_modified", "latest_version", "type", "size",
"data_store", "document", "user_uid", "url"
]
unknown = INCLUDE
type = EnumField(FileType)
url = Method("get_url")
def get_url(self, obj):
token = 'not_available'
if obj.id is None:
return "" # We can't return a url for a file that isn't stored yet.
file_url = url_for("/v1_0.crc_api_file_get_file_data_link",
file_id=obj.id,
_external=True)
if hasattr(flask.g, 'user'):
token = flask.g.user.encode_auth_token()
url = file_url + '?auth_token=' + urllib.parse.quote_plus(token)
return url
class BlockingSchema(mm.ModelSchema):
blocked_rooms = Nested(BlockedRoomSchema, many=True)
allowed = Nested(BlockingPrincipalSchema, many=True)
permissions = Method('_get_permissions')
created_by = Nested(UserSchema,
attribute='created_by_user',
only='full_name')
class Meta:
model = Blocking
fields = ('id', 'start_date', 'end_date', 'reason', 'blocked_rooms',
'allowed', 'created_by', 'permissions')
def _get_permissions(self, blocking):
methods = ('can_delete', 'can_edit')
admin_permissions = None
user_permissions = {
x: getattr(blocking, x)(session.user, allow_admin=False)
for x in methods
}
if rb_is_admin(session.user):
admin_permissions = {
x: getattr(blocking, x)(session.user)
for x in methods
}
return {'user': user_permissions, 'admin': admin_permissions}
class ReservationDetailsSchema(mm.SQLAlchemyAutoSchema):
booked_for_user = Nested(UserSchema, only=('id', 'identifier', 'full_name', 'phone', 'email'))
created_by_user = Nested(UserSchema, only=('id', 'identifier', 'full_name', 'email'))
edit_logs = Nested(ReservationEditLogSchema, many=True)
can_accept = Function(lambda booking: booking.can_accept(session.user))
can_cancel = Function(lambda booking: booking.can_cancel(session.user))
can_delete = Function(lambda booking: booking.can_delete(session.user))
can_edit = Function(lambda booking: booking.can_edit(session.user))
can_reject = Function(lambda booking: booking.can_reject(session.user))
permissions = Method('_get_permissions')
state = EnumField(ReservationState)
is_linked_to_object = Function(lambda booking: booking.link is not None)
link = Nested(ReservationLinkSchema)
start_dt = NaiveDateTime()
end_dt = NaiveDateTime()
class Meta:
model = Reservation
fields = ('id', 'start_dt', 'end_dt', 'repetition', 'booking_reason', 'created_dt', 'booked_for_user',
'room_id', 'created_by_user', 'edit_logs', 'permissions',
'is_cancelled', 'is_rejected', 'is_accepted', 'is_pending', 'rejection_reason',
'is_linked_to_object', 'link', 'state', 'external_details_url')
def _get_permissions(self, booking):
methods = ('can_accept', 'can_cancel', 'can_delete', 'can_edit', 'can_reject')
admin_permissions = None
user_permissions = {x: getattr(booking, x)(session.user, allow_admin=False) for x in methods}
if rb_is_admin(session.user):
admin_permissions = {x: getattr(booking, x)(session.user) for x in methods}
return {'user': user_permissions, 'admin': admin_permissions}
class HotelSchema(Schema):
id = Integer(required=True)
name = String(required=True)
is_active = Boolean(data_key=HotelCamelKey.mapping['is_active'],
required=True)
description = String(required=True)
city_or_province = String(
data_key=HotelCamelKey.mapping['city_or_province'], required=True)
address = String(required=True)
longitude = Float(required=True)
latitude = Float(required=True)
checkin = DateTime(format='%H:%M', required=True)
checkout = DateTime(format='%H:%M', required=True)
utilities = Method(serialize='get_utilities')
room_types = Method(serialize='get_room_types',
data_key=HotelCamelKey.mapping['room_types'])
phone_number = String(data_key=HotelCamelKey.mapping['phone_number'],
required=True)
email = String(required=True)
image = String(required=True)
price_standard = Float(data_key=HotelCamelKey.mapping['price_standard'])
available_room_standard = Integer(
data_key=HotelCamelKey.mapping['available_room_standard'])
tax_standard = Float(data_key=HotelCamelKey.mapping['tax_standard'])
image_standard = String(data_key=HotelCamelKey.mapping['image_standard'])
price_deluxe = Float(data_key=HotelCamelKey.mapping['price_deluxe'])
available_room_deluxe = Integer(
data_key=HotelCamelKey.mapping['available_room_deluxe'],
allow_none=True)
tax_deluxe = Float(data_key=HotelCamelKey.mapping['tax_deluxe'])
image_deluxe = String(data_key=HotelCamelKey.mapping['image_deluxe'])
def get_utilities(self, obj):
utilities = obj.utilities
if utilities is not None:
utilities = utilities.split(',')
return utilities
def get_room_types(self, obj):
room_types = obj.room_types
if room_types is not None:
room_types = room_types.split(',')
return room_types
class ReservationLinkedObjectDataSchema(Schema):
id = Number()
title = Method('_get_title')
url = String()
event_title = Function(lambda obj: obj.event.title)
event_url = Function(lambda obj: obj.event.url)
def _get_title(self, object):
if isinstance(object, SessionBlock):
return object.full_title
return object.title
class CommentSchema(ma.Schema):
id = String(dump_only=True)
post_id = Integer(dump_only=True)
user_id = Integer(dump_only=True)
content = String(required=True)
parent_comment = String(load_only=True)
comments = Method("get_comments")
def get_comments(self, obj):
print(obj.comments)
return obj.comments
class GammaCounterRunSchema(BaseSchema):
class Meta(BaseSchema.Meta):
model = GammaCounterRun
gamma_counter = Nested(GammaCounter.Schema, many=False, dump_only=True)
calibrations = Nested(CalibrationSchema, many=False, dump_only=True)
custom_calibration = Nested(CustomCalibrationSchema, many=False, dump_only=True)
vials = Method('vials_count')
def vials_count(self, obj):
return len(obj.vials)
class ReservationLinkedObjectDataSchema(mm.Schema):
id = Number()
title = Method('_get_title')
event_title = Function(lambda obj: obj.event.title)
event_url = Function(lambda obj: obj.event.url)
own_room_id = Number()
own_room_name = Function(lambda obj: (obj.own_room.name if obj.own_room else obj.own_room_name) or None)
def _get_title(self, obj):
if isinstance(obj, SessionBlock):
return obj.full_title
return obj.title
class ReservationOccurrenceSchemaWithPermissions(ReservationOccurrenceSchema):
permissions = Method('_get_permissions')
class Meta:
fields = ReservationOccurrenceSchema.Meta.fields + ('permissions',)
def _get_permissions(self, occurrence):
methods = ('can_cancel', 'can_reject')
admin_permissions = None
user_permissions = {x: getattr(occurrence, x)(session.user, allow_admin=False) for x in methods}
if rb_is_admin(session.user):
admin_permissions = {x: getattr(occurrence, x)(session.user) for x in methods}
return {'user': user_permissions, 'admin': admin_permissions}
class DataSourceSerializer(Schema):
source_type = Str()
url = URL()
title = Str()
last_import_timestamp = DateTime()
update_frequency = Method('get_update_frequency')
def get_update_frequency(self, obj):
translations = {}
for lang in settings.MODELTRANS_AVAILABLE_LANGUAGES:
with override(lang):
translations[lang] = str(obj.get_frequency_in_days_display())
return translations
class UIListSchema(Schema):
"""Schema for dumping extra information in the UI."""
class Meta:
"""."""
unknown = INCLUDE
hits = Method("get_hits")
aggregations = Method("get_aggs")
def get_hits(self, obj_list):
"""Apply hits transformation."""
for obj in obj_list["hits"]["hits"]:
obj[self.context["object_key"]] = self.context[
"object_schema_cls"]().dump(obj)
return obj_list["hits"]
def get_aggs(self, obj_list):
"""Apply aggregations transformation."""
aggs = obj_list.get("aggregations")
if not aggs:
return missing
return aggs
class ReservationLinkedObjectDataSchema(Schema):
id = Number()
title = Method('_get_title')
event_title = Function(lambda obj: obj.event.title)
event_url = Function(lambda obj: obj.event.url)
own_room_id = Number()
own_room_name = Function(lambda obj: (obj.own_room.name if obj.own_room else obj.own_room_name) or None)
class Meta:
strict = True # TODO: remove with marshmallow 3
def _get_title(self, obj):
if isinstance(obj, SessionBlock):
return obj.full_title
return obj.title
class AnalysisSystemInstanceSchema(BaseSchema):
url = URLFor('.analysis_system_instance_detail',
uuid='<uuid>',
_external=True)
analysis_system = ForeignReferenceField(endpoint='.analysis_system_detail',
queryset=AnalysisSystem.objects(),
query_parameter='identifier_name')
is_online = Boolean()
scheduled_analyses_count = Method("get_scheduled_analyses_count")
class Meta(BaseSchema.Meta):
model = AnalysisSystemInstance
dump_only = ['id', '_cls', 'last_seen', 'scheduled_analyses_count']
def get_scheduled_analyses_count(self, obj):
analyses_count = ScheduledAnalysis.objects(
analysis_system_instance=obj).count()
return analyses_count
class PaperReviewSchema(mm.SQLAlchemyAutoSchema):
score = Decimal(places=2, as_string=True)
user = Nested(UserSchema)
visibility = Nested(PaperCommentVisibilitySchema)
proposed_action = Nested(PaperAction)
ratings = Nested(PaperRatingSchema, many=True)
group = Nested(PaperReviewTypeSchema, attribute='group.instance')
comment_html = Function(lambda review: escape(review.comment))
can_edit = Method('_can_edit_review')
class Meta:
model = PaperReview
fields = ('id', 'score', 'created_dt', 'user', 'comment', 'comment_html', 'modified_dt', 'visibility',
'proposed_action', 'group', 'ratings', 'can_edit')
def _can_edit_review(self, review):
user = self.context.get('user')
cfp = review.revision.paper.cfp
return review.can_edit(user, check_state=True) and is_type_reviewing_possible(cfp, review.type)
class UserSchema(SQLAlchemyAutoSchema):
"""Schema for user model."""
class Meta:
"""Options for model schema."""
model = User
exclude = ('id', 'created_at')
load_instance = True
user_type = Method(deserialize='usertype_name_to_id')
def usertype_name_to_id(self, user_type_input):
"""Custom method for deserialization of usertype name to id"""
usertype = UserType.query.filter_by(name=user_type_input).first()
if usertype is None:
raise ValidationError(message='user type not supported')
return usertype.id
class TemporalSchemaForm(ModelSchema):
"""Form definition for model TemporalCompositionSchema."""
class Meta:
"""Internal meta information of Form interface."""
model = TemporalCompositionSchema
sqla_session = db.session
id = String(dump_only=True)
temporal_composite_unit = Method(deserialize='load_temporal_composite')
def load_temporal_composite(self, value):
"""Validate temporal composite with all supported values."""
if value in DEFAULT_TEMPORAL_UNITS:
return value
raise RuntimeError(
'Invalid temporal unit. Supported values: {}'.format(
DEFAULT_TEMPORAL_UNITS))
def __new__(mcs, name, bases, attrs):
parents = [b for b in bases if isinstance(b, JsonApiSerializerMeta)]
if not parents:
return super(JsonApiSerializerMeta,
mcs).__new__(mcs, name, bases, attrs)
meta = attrs.pop('Meta', None)
try:
model = meta.model
except AttributeError:
raise TypeError(
u"Class '{}' is missing the 'Meta.model' attribute.".format(
name))
schema_type = type_from_model_name(model.__name__)
meta_bases = (meta, object) if meta else (object, )
schema_attrs = {
'Meta':
type('Meta', meta_bases, {
'type_': schema_type,
'inflect': dasherize,
})
}
links = getattr(meta, 'links', {})
for attrname, field in iteritems(model._fields):
if isinstance(field, OrmField):
field_copy = object.__new__(field.__class__)
field_copy.__dict__ = dict(field.__dict__)
field_copy.load_from = None
field_copy.dump_to = None
schema_attrs[attrname] = field_copy
elif isinstance(field, BaseRelationship):
rel_links = links.get(attrname, {})
rel_many = isinstance(field, HasMany)
rel_options = {
'self_url': rel_links.get('self', ''),
'related_url': rel_links.get('related', ''),
'many': rel_many
}
if not rel_many:
rel_options['allow_none'] = True
if field.polymorphic:
schema_attrs[attrname] = PolymorphicRelationship(
**rel_options)
else:
schema_attrs[attrname] = Relationship(
type_=type_from_model_name(field.model.__name__),
id_field='pk',
serializer=rel_links.get('serializer'),
**rel_options)
if 'id' not in schema_attrs:
pk_field = model._fields[model._pk_field]
schema_attrs['id'] = type(pk_field)(attribute=model._pk_field)
# we need to access the serialized object to generate the url, but
# get_resource_links takes the serialized item, so we add a method field
# to do the work
schema_attrs['_url'] = Method('get_url')
attrs.update(schema_attrs)
cls = super(JsonApiSerializerMeta,
mcs).__new__(mcs, name, bases, attrs)
# add new schema to registry by type
is_custom = name.replace('Serializer', '') != model.__name__
key = camel_case_to_dashes(name) if is_custom else schema_type
schemas[key] = cls
return cls
class Meta:
# model = Demande
table = mapper.metadata.tables["v3_demandes"]
include = {
# Permissions
"acces_restreint": Method("get_acces_restreint"),
"is_editable": Method("get_is_editable"),
"is_duplicable": Method("get_is_duplicable"),
"feuille_cout_editable": Method("get_feuille_cout_editable"),
# Key users
"contact_labco": Method("get_contact_labco"),
"porteur": Method("get_porteur"),
"gestionnaire": Method("get_gestionnaire"),
"contributeurs": Method("get_contributeurs"),
# Structure
"structure": Method("get_structure"),
# Form
"form_data": Method("get_form_data"),
# For tabs
"pieces_jointes": Method("get_pieces_jointes"),
"workflow": Method("get_workflow"),
"workflow_history": Method("get_history"),
"past_versions": Method("get_past_versions"),
"is_valid": Method("get_is_valid"),
"errors": Method("get_errors"),
"extra_errors": Method("get_extra_errors"),
}
