class TokenPayloadSchema(ModelSchema):
user_id = Function(lambda obj: obj.id)
scopes = Function(lambda _: ['user', 'admin'])
class Meta:
model = User
fields = ('user_id', 'username', 'scopes')
class PaperFileSchema(mm.SQLAlchemyAutoSchema):
icon = Function(lambda paper_file: icon_from_mimetype(paper_file.content_type))
download_url = Function(lambda paper_file: url_for('papers.download_file', paper_file))
class Meta:
model = PaperFile
fields = ('id', 'revision_id', 'content_type', 'filename', 'icon', 'download_url')
class HealthServiceSlotSchema(ma.ModelSchema):
site = SmartNested(HealthServiceSiteSchema)
start = Function(lambda obj: time.mktime(obj.start.timetuple()) * 1000.0)
end = Function(lambda obj: time.mktime(obj.end.timetuple()) * 1000.0)
class Meta:
model = HealthServiceTimeSlot
sqla_session = db.session
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 PaperSchema(mm.Schema):
is_in_final_state = Boolean()
contribution = Nested(ContributionSchema)
event = Nested(PaperEventSchema)
revisions = List(Nested(PaperRevisionSchema))
last_revision = Nested(PaperRevisionSchema)
state = Nested(PaperRevisionStateSchema)
rating_range = List(Integer(), attribute='cfp.rating_range')
can_judge = Function(lambda paper, ctx: paper.can_judge(ctx.get('user')))
can_comment = Function(lambda paper, ctx: paper.can_comment(ctx.get('user')))
can_review = Function(lambda paper, ctx: paper.can_review(ctx.get('user')))
class PaperSchema(mm.Schema):
is_in_final_state = Boolean()
contribution = Nested(ContributionSchema)
event = Nested(PaperEventSchema)
revisions = List(Nested(PaperRevisionSchema))
last_revision = Nested(PaperRevisionSchema)
state = Nested(PaperRevisionStateSchema)
can_judge = Function(lambda paper, ctx: paper.can_judge(ctx.get('user')))
can_comment = Function(lambda paper, ctx: paper.can_comment(
ctx.get('user'), check_state=True))
can_review = Function(lambda paper, ctx: paper.can_review(ctx.get('user')))
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 PaperReviewCommentSchema(mm.SQLAlchemyAutoSchema):
user = Nested(UserSchema)
visibility = Nested(PaperCommentVisibilitySchema)
modified_by = Nested(UserSchema)
html = Function(lambda comment: escape(comment.text))
can_edit = Function(lambda comment, ctx: comment.can_edit(ctx.get('user')))
can_view = Function(lambda comment, ctx: comment.can_view(ctx.get('user')))
class Meta:
model = PaperReviewComment
fields = ('id', 'user', 'text', 'html', 'visibility', 'created_dt',
'modified_dt', 'modified_by', 'can_edit', 'can_view')
class PaperReviewSchema(mm.ModelSchema):
score = Float(as_string=True)
user = Nested(UserSchema)
visibility = Nested(PaperCommentVisibilitySchema)
proposed_action = Nested(PaperAction)
group = Function(lambda review: {'title': unicode(review.group.title)})
ratings = Function(lambda review: [{'value': rating.value} for rating in review.ratings])
comment_html = Function(lambda review: escape(review.comment))
can_edit = Function(lambda review, ctx: review.can_edit(ctx.get('user')))
can_view = Function(lambda review, ctx: review.can_view(ctx.get('user')))
class Meta:
model = PaperReview
fields = ('id', 'score', 'created_dt', 'user', 'comment', 'comment_html', 'modified_dt', 'visibility',
'proposed_action', 'group', 'ratings', 'can_edit', 'can_view')
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 PaymentSchema(Schema):
"""Schema used to serialize and deserialize payment objects."""
id = Integer(dump_only=True)
transaction_id = Str(required=True)
amount = Str(required=True, validate=is_decimal)
currency = Str(required=True, validate=validate.Length(min=3, max=3)) # validate the size of the currency
status = Function(serialize=lambda p: p.status.value if isinstance(p.status, Enum) else p.status,
validate=lambda x: hasattr(Status, x)) # return only the value of the status
# validate whether it is a valid payment method
payment_method = Function(serialize=lambda x: x.payment_method.value, required=True,
validate=lambda x: hasattr(PaymentMethod, x))
@post_load
def make_payment(self, data):
return Payment(**data, status=Status.CREATED)
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 PaperReviewSchema(mm.ModelSchema):
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 = Function(
lambda review, ctx: review.can_edit(ctx.get('user'), check_state=True))
class Meta:
model = PaperReview
fields = ('id', 'score', 'created_dt', 'user', 'comment',
'comment_html', 'modified_dt', 'visibility',
'proposed_action', 'group', 'ratings', 'can_edit')
class UserSchema(mm.SQLAlchemyAutoSchema):
identifier = Function(lambda user: user.identifier)
class Meta:
model = User
fields = ('id', 'identifier', 'first_name', 'last_name', 'email',
'affiliation', 'full_name', 'phone', 'avatar_url')
class TagSchema(Schema):
id = Integer(dump_only=True)
created_at = DateTime(dump_only=True)
updated_at = DateTime(dump_only=True)
author = Function(lambda o: o.user.username)
tag = String(strip=True, validate=Length(max=16))
class ReservationLinkSchema(mm.SQLAlchemyAutoSchema):
type = EnumField(LinkType, attribute='link_type')
id = Function(lambda link: link.object.id)
class Meta:
model = ReservationLink
fields = ('type', 'id')
class EquipmentTypeSchema(mm.SQLAlchemyAutoSchema):
features = Nested(RoomFeatureSchema, many=True)
used = Function(lambda eq, ctx: eq.id in ctx['used_ids'])
class Meta:
model = EquipmentType
fields = ('id', 'name', 'features', 'used')
class UserSchema(mm.ModelSchema):
identifier = Function(lambda user: user.identifier)
class Meta:
model = User
fields = ('id', 'identifier', 'first_name', 'last_name', 'email',
'affiliation', 'avatar_bg_color', 'full_name')
class AdminLocationsSchema(mm.ModelSchema):
can_delete = Function(lambda loc: not loc.rooms)
class Meta:
model = Location
fields = ('id', 'name', 'can_delete', 'map_url_template',
'room_name_format')
class BlockingSchema(mm.ModelSchema):
blocked_rooms = Nested(BlockedRoomSchema, many=True)
allowed = Nested(BlockingPrincipalSchema, many=True)
can_edit = Function(lambda blocking: blocking.can_be_modified(session.user))
class Meta:
model = Blocking
fields = ('id', 'start_date', 'end_date', 'reason', 'blocked_rooms', 'allowed', 'created_by_id', 'can_edit')
class BlockingPrincipalSchema(mm.ModelSchema):
identifier = Function(lambda blocking_principal: blocking_principal.identifier)
full_name = String()
provider = String(missing=None)
email = String(missing=None)
is_group = Boolean(missing=False)
class Meta:
model = BlockingPrincipal
fields = ('id', 'identifier', 'name', 'is_group', 'email', 'full_name', 'provider')
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 ReservationDetailsSchema(mm.ModelSchema):
booked_for_user = Nested(UserSchema, only=('full_name', 'phone', 'email'))
created_by_user = Nested(UserSchema, only=('full_name', ))
edit_logs = Nested(ReservationEditLogSchema, many=True)
can_accept = Function(
lambda booking: booking.can_be_accepted(session.user))
can_cancel = Function(
lambda booking: booking.can_be_cancelled(session.user))
can_delete = Function(lambda booking: booking.can_be_deleted(session.user))
can_modify = Function(
lambda booking: booking.can_be_modified(session.user))
can_reject = Function(
lambda booking: booking.can_be_rejected(session.user))
is_linked_to_event = Function(lambda booking: booking.event_id is not None)
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', 'can_accept', 'can_cancel',
'can_delete', 'can_modify', 'can_reject', 'is_cancelled',
'is_rejected', 'is_accepted', 'is_pending',
'rejection_reason', 'is_linked_to_event')
class JobsSerializer(Schema):
company = Str(required=True)
company_logo = Str(required=True)
company_url = Str(required=True)
created_at = Str(required=True)
description = Str(required=True)
fulltime = Bool(required=True)
how_to_apply = Str(required=True)
id = UUID(required=True)
location = Str(required=True)
title = Str(required=True)
fulltime = Function(lambda obj: obj["type"] == "Full Time", data_key="fulltime")
class PaperRevisionSchema(mm.ModelSchema):
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))
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')
class InvoiceSchema(BaseSchema):
id = Function(deserialize=(lambda id: id.get("IDs")[0]), required=True)
reason = String(required=True)
status = String(required=True)
url = String()
currency = String(required=True)
total = Integer(required=True)
taxAmount = Integer(attribute="tax_amount")
paymentStatus = Nested(PaymentStatusSchema, attribute="payment_status")
lineItems = List(Nested(InvoiceItemSchema), attribute="items")
@post_load
def make_invoice(self, data, **kwargs) -> Invoice:
return Invoice(**data)
class PostSchema(Schema):
id = Integer(dump_only=True)
created_at = DateTime(dump_only=True)
updated_at = DateTime(dump_only=True)
author = Function(lambda o: o.user.username)
title = String(required=True,
strip=True,
validate=[NotEmpty(), Length(min=1, max=32)])
sub = String(required=True, strip=True, validate=Length(max=128))
content = String(required=True, validate=NotEmpty())
statuses = Nested(StatusSchema,
only=('created_at', 'status'),
many=True,
dump_only=True)
comments = Nested(CommentSchema, many=True, dump_only=True)
tags = Nested(StatusSchema, only=('tag', ), many=True, dump_only=True)
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 PaperSchema(mm.Schema):
is_in_final_state = Boolean()
contribution = Nested(ContributionSchema)
event = Nested(PaperEventSchema)
revisions = List(Nested(PaperRevisionSchema))
last_revision = Nested(PaperRevisionSchema)
state = Nested(PaperRevisionStateSchema)
can_manage = Function(lambda paper, ctx: paper.cfp.is_manager(ctx.get('user')))
can_judge = Function(lambda paper, ctx: paper.can_judge(ctx.get('user')))
can_comment = Function(lambda paper, ctx: paper.can_comment(ctx.get('user'), check_state=True))
can_review = Function(lambda paper, ctx: paper.can_review(ctx.get('user')))
can_submit_proceedings = Function(lambda paper, ctx: paper.contribution.can_submit_proceedings(ctx.get('user')))
editing_open = Function(
lambda paper, ctx: editable_type_settings[EditableType.paper].get(paper.event, 'submission_enabled')
)
editing_enabled = Function(
lambda paper, ctx: paper.event.has_feature('editing')
and 'paper' in editing_settings.get(paper.event, 'editable_types')
)
class ReservationEventDataSchema(Schema):
id = Number()
title = String()
url = String()
can_access = Function(lambda event: event.can_access(session.user))
