class UserExportSchema(ModelSchema):
""" Used exclusively for data export, removes identifying information"""
class Meta(ModelSchema.Meta):
model = User
fields = ('id', 'last_updated', 'role', 'email_verified', 'email',
'_links')
role = EnumField(Role)
email = ma.Function(lambda obj: missing if obj is None else str(obj.id))
_links = ma.Hyperlinks({
'self': ma.URLFor('api.userendpoint', id='<id>'),
})
class ParticipantExportSchema(ModelSchema):
""" Used exclusively for data export, removes identifying information"""
class Meta(ModelSchema.Meta):
model = Participant
fields = ('id', 'last_updated', 'user_id', 'relationship',
'avatar_icon', 'avatar_color', '_links')
relationship = EnumField(Relationship)
_links = ma.Hyperlinks({
'self':
ma.URLFor('api.participantendpoint', id='<id>'),
})
class RunSchema(BaseSchema):
id = fields.UUID(data_key="runId", required=True)
run_number = fields.Integer(data_key="runNumber", required=True)
state = EnumField(RunState, by_value=True, required=True)
submitted_at = fields.DateTime(data_key="submittedAt", required=True)
started_at = fields.DateTime(data_key="startedAt", missing=None)
ended_at = fields.DateTime(data_key="endedAt", missing=None)
subruns = fields.Nested(SubrunSummarySchema, many=True, required=True)
@post_load
def make_run(self, data):
return Run(**data)
class RHMatchingEvents(RHRoomBookingBase):
"""Get events suitable for booking linking."""
@use_kwargs({
'start_dt': fields.DateTime(),
'end_dt': fields.DateTime(),
'repeat_frequency': EnumField(RepeatFrequency, missing='NEVER'),
'repeat_interval': fields.Int(missing=1),
})
def _process(self, start_dt, end_dt, repeat_frequency, repeat_interval):
events = get_matching_events(start_dt, end_dt, repeat_frequency, repeat_interval)
return jsonify(reservation_user_event_schema.dump(events).data)
class OfficeSchema(ma.ModelSchema):
class Meta:
fields = ("officeId", "officeName", "officeType", "electionId",
"parentOffice")
model = TallySheet.Model
# optionally attach a Session
# to use for deserialization
sqla_session = db.session
officeType = EnumField(OfficeTypeEnum)
parentOffice = ma.Nested('self')
class RHCreateBooking(RHRoomBookingBase):
def _validate_room_booking_limit(self, start_dt, end_dt,
booking_limit_days):
day_start_dt = datetime.combine(start_dt.date(), time())
day_end_dt = datetime.combine(end_dt.date(), time(23, 59))
selected_period_days = (day_end_dt - day_start_dt).days
return selected_period_days <= booking_limit_days
@use_args({
'start_dt':
fields.DateTime(required=True),
'end_dt':
fields.DateTime(required=True),
'repeat_frequency':
EnumField(RepeatFrequency, required=True),
'repeat_interval':
fields.Int(missing=0),
'room_id':
fields.Int(required=True),
'user_id':
fields.Int(),
'booking_reason':
fields.String(load_from='reason', validate=validate.Length(min=3)),
'is_prebooking':
fields.Bool(missing=False)
})
def _process(self, args):
room = Room.get_one(args.pop('room_id'))
user_id = args.pop('user_id', None)
booked_for = User.get_one(user_id) if user_id else session.user
is_prebooking = args.pop('is_prebooking')
# Check that the booking is not longer than allowed
booking_limit_days = room.booking_limit_days or rb_settings.get(
'booking_limit')
if not self._validate_room_booking_limit(
args['start_dt'], args['end_dt'], booking_limit_days):
msg = (
_('Bookings for the room "{}" may not be longer than {} days'
).format(room.name, booking_limit_days))
return jsonify(success=False, msg=msg)
try:
resv = Reservation.create_from_data(
room,
dict(args, booked_for_user=booked_for),
session.user,
prebook=is_prebooking)
db.session.flush()
except NoReportError as e:
db.session.rollback()
raise ExpectedError(unicode(e))
return jsonify(booking=reservation_schema.dump(resv).data)
class Ballot_Schema(ma.ModelSchema):
class Meta:
fields = ("ballotId", "ballotType", "electionId", "stationaryItemId",
"available")
model = Ballot.Model
# optionally attach a Session
# to use for deserialization
sqla_session = db.session
ballotType = EnumField(BallotTypeEnum)
stationaryItem = ma.Nested(StationaryItem_Schema)
class ElectorateSchema(ma.ModelSchema):
class Meta:
fields = ("electorateId", "electorateName", "electorateType",
"electionId", "parentelectorate")
model = Electorate.Model
# optionally attach a Session
# to use for deserialization
sqla_session = db.session
electorateType = EnumField(ElectorateTypeEnum)
parentelectorate = ma.Nested('self')
class RHExportEventICAL(RHDisplayEventBase):
@use_kwargs(
{
'scope': EnumField(CalendarScope, load_default=None),
'detail': fields.String(load_default=None)
},
location='query')
def _process(self, scope, detail):
if not scope and detail == 'contributions':
scope = CalendarScope.contribution
event_ical = event_to_ical(self.event, session.user, scope)
return send_file('event.ics', BytesIO(event_ical), 'text/calendar')
class MesslokationszuordnungSchema(Schema, JavaScriptMixin):
# required attributes
messlokations_id = fields.Str()
arithmetik = EnumField(ArithmetischeOperation)
# optional attributes
gueltig_seit = fields.DateTime(missing=None)
gueltig_bis = fields.DateTime(missing=None)
@post_load
def deserialise(self, data, **kwargs) -> Messlokationszuordnung:
return Messlokationszuordnung(**data)
class FolderSchema(BaseSchema):
__model__ = Folder
id = fields.Integer()
name = fields.String(required=True)
type = EnumField(FolderType, required=True)
image_url = fields.URL(required=False, allow_none=True)
category_id = fields.Integer(required=True)
notes = fields.Nested(NoteSchema,
many=True,
dump_only=True,
only=("id", "title", "tags", "folder_id"))
class CreateBookingSchema(Schema):
start_dt = fields.DateTime(required=True)
end_dt = fields.DateTime(required=True)
repeat_frequency = EnumField(RepeatFrequency, required=True)
repeat_interval = fields.Int(missing=0, validate=lambda x: x >= 0)
room_id = fields.Int(required=True)
user_id = fields.Int()
booking_reason = fields.String(load_from='reason',
validate=validate.Length(min=3))
is_prebooking = fields.Bool(missing=False)
link_type = EnumField(LinkType)
link_id = fields.Int()
link_back = fields.Bool(missing=False)
class Meta:
strict = True
@validates_schema(skip_on_field_errors=True)
def validate_dts(self, data):
if data['start_dt'] >= data['end_dt']:
raise ValidationError(_('Booking cannot end before it starts'))
class MessageSchema(Schema):
__model__ = MessageEntity
uuid = fields.Str(missing=lambda: str(uuid4()))
title = fields.Str(required=True, validate=validate.Length(min=2, max=150))
description = fields.Str(required=False)
severity = EnumField(Severity,
missing=Severity.UNKNOWN,
validate=validate.OneOf([e.value for e in Severity]))
type = fields.Str(missing=MessageType.INFORMATION.value,
validate=validate.OneOf([e.value for e in MessageType]))
type_label = fields.Method("_build_type_label")
creator_id = fields.Str(required=False, dump_only=True)
creator = fields.Nested(UserSchema, dump_only=True)
started_at = fields.DateTime(required=False)
tags = fields.Nested(TagSchema, many=True, dump_only=True)
parent = fields.Nested('MessageSchema', required=False, dump_only=True)
parent_id = fields.Str(required=False, load_only=True)
resources = fields.Nested(ResourceSchema,
required=False,
many=True,
dump_only=True)
executor_id = fields.Str(required=False)
reactions = fields.Nested(ReactionSchema,
required=False,
many=True,
dump_only=True)
done_at = fields.DateTime(default=None, dump_only=True)
restricted = fields.Method("_is_restricted")
created_at = fields.DateTime(missing=lambda: datetime.now(),
dump_only=True)
updated_at = fields.DateTime(missing=lambda: datetime.now(),
dump_only=True)
@post_load
def make_message(self, data: dict, **kwargs):
entity = MessageEntity.from_dict(data)
return entity
def _build_type_label(self, obj) -> str:
return MessageType.get_label(message_type=obj.type)
def _is_restricted(self, obj) -> bool:
if obj.restricted_to:
return True
else:
return False
def handle_error(self, exc, data, **kwargs):
error_data = exc.normalized_messages()
error_data["valid"] = [e for e in MessageType]
raise MessageValidationError(description=error_data)
class WorkerPublicSchema(Schema):
id = fields.Integer()
ean13 = fields.String()
name = fields.String()
surname = fields.String()
middle_name = fields.String()
type = EnumField(WorkerType)
deleted = fields.Boolean()
class Meta:
type_ = "worker"
class RHConfirmEditableChanges(RHContributionEditableRevisionBase):
"""Confirm/reject the changes made by the editor on an Editable."""
def _check_revision_access(self):
return self._user_is_authorized_submitter()
@use_kwargs({
'action': EnumField(EditingConfirmationAction, required=True),
'comment': fields.String(missing='')
})
def _process(self, action, comment):
confirm_editable_changes(self.revision, session.user, action, comment)
return '', 204
class WasherSchema(ma.SQLAlchemyAutoSchema):
type = EnumField(Machine, by_value=True)
class Meta:
model = Washer
include_relationships = True
repair_logs = ma.List(ma.Nested(RepairLogSchema))
@post_load
def make_machine(self, data, **kwargs):
return Washer(**data)
class SourceSchema(Schema):
id = fields.Int(dump_only=True)
uuid = fields.UUID(dump_only=True)
name = fields.Str(allow_none=False)
source_type = EnumField(SourceType, allow_none=False)
source_status = EnumField(SourceStatus, allow_none=True)
term_sources = fields.List(fields.Nested(TermSourcesSchema))
versions = fields.Nested(SourceVersionSchema, many=True)
repository = fields.Nested(RepositorySchema)
data = fields.Nested(SourceDataSchema, many=False, unknown=INCLUDE)
@post_dump(pass_original=True)
def fix_data_field(self, result, source: Source, **kwargs):
# este metodo hace lento el dump, solo es necesario cuando se requiere un source,
# para una lista, es mejor no hacer el metodo, porque es muy lento.
if not kwargs['many']:
if source.source_type == SourceType.JOURNAL:
# print("is a journal !!!!! #######")
data = journal_data_schema.dump(source.data)
else:
data = source_base_data_schema.dump(source.data)
result['data'] = data
return result
@post_dump
def dump_need_review_version(self, source, **kwargs):
# TODO: version_to_review is true cuando tiene una version con una fecha posterior a la
# version current.
versions = SourceVersion.query.filter_by(
source_id=source['id']).order_by(desc(
SourceVersion.created_at)).first()
if versions and not versions.is_current:
source['version_to_review'] = True
else:
source['version_to_review'] = False
return source
class ProfileSchema(Schema):
PayloadDescription = fields.Str(attribute='description')
PayloadDisplayName = fields.Str(attribute='display_name')
PayloadExpirationDate = fields.DateTime(attribute='expiration_date')
PayloadIdentifier = fields.Str(attribute='identifier', required=True)
PayloadOrganization = fields.Str(attribute='organization')
PayloadUUID = fields.UUID(attribute='uuid')
PayloadRemovalDisallowed = fields.Bool(attribute='removal_disallowed')
PayloadType = fields.Function(lambda obj: 'Configuration',
attribute='payload_type')
PayloadVersion = fields.Function(lambda obj: 1, attribute='version')
PayloadScope = EnumField(PayloadScope, attribute='scope')
RemovalDate = fields.DateTime(attribute='removal_date')
DurationUntilRemoval = fields.Float(attribute='duration_until_removal')
ConsentText = fields.Nested(ConsentTextSchema())
PayloadContent = fields.Method('get_payloads', deserialize='load_payloads')
def get_payloads(self, obj):
payloads = []
for payload in obj.payloads:
schema = schema_for(payload.type)
if schema is not None:
result = schema().dump(payload)
payloads.append(result.data)
else:
print('Unsupported PayloadType: {}'.format(payload.type))
return payloads
def load_payloads(self, payload_content: list) -> List[Schema]:
payloads = []
for content in payload_content:
schema = schema_for(content['PayloadType'])
if schema is not None:
result = schema().load(content)
payloads.append(result.data)
else:
print('Unsupported PayloadType: {}'.format(
content['PayloadType']))
return payloads
@post_load
def make_profile(self, data):
payloads = data.pop('PayloadContent', [])
p = models.Profile(**data)
# for pl in payloads:
# p.payloads.append(pl)
return p
class JobDefinitionSchema(BaseSchema):
working_dir = fields.String(data_key="workingDir", required=True)
command = fields.Nested(JobCommandSchema, required=True)
image_type = EnumField(
ImageType, by_value=True, data_key="imageType", required=True
)
conda_environment = fields.String(
data_key="condaEnvironment", missing=None
)
environment_ids = fields.List(
fields.String(), data_key="environmentIds", required=True
)
instance_size_type = fields.String(
data_key="instanceSizeType", required=True
)
instance_size = fields.Nested(
InstanceSizeSchema, data_key="instanceSize", missing=None
)
max_runtime_seconds = fields.Integer(
data_key="maxRuntimeSeconds", required=True
)
@validates_schema
def validate_conda_environment(self, data):
image_is_r = data["image_type"] == ImageType.R
image_is_python = data["image_type"] == ImageType.PYTHON
conda_environment_set = data["conda_environment"] is not None
if image_is_r and conda_environment_set:
raise ValidationError(
"conda environment must only be set for Python images"
)
elif image_is_python and not conda_environment_set:
raise ValidationError(
"conda environment must be set for Python images"
)
@validates_schema
def validate_instance_size(self, data):
custom_type = data["instance_size_type"] == "custom"
instance_size_set = data["instance_size"] is not None
if custom_type and not instance_size_set:
raise ValidationError(
"need to specify instance size for custom instances"
)
elif not custom_type and instance_size_set:
raise ValidationError(
"instance_size must be None for non-custom instances "
)
@post_load
def make_job_definition(self, data):
return JobDefinition(**data)
class LocationSchema(Schema):
__model__ = LocationEntity
uuid = fields.Str(missing=lambda: str(uuid4()))
label = fields.Str(required=True)
slug = fields.Str(dump_only=True)
external_id = fields.Str(dump_only=True)
search_label = fields.Str(dump_only=True)
type = EnumField(LocationType, validate=validate.OneOf([e.value for e in LocationType]))
@post_load
def make_location(self, data: dict, **kwargs):
return LocationEntity.from_dict(data)
class BlockedRoomSchema(mm.SQLAlchemyAutoSchema):
room = Nested(RoomSchema, only=('id', 'name', 'sprite_position', 'full_name'))
state = EnumField(BlockedRoomState)
class Meta:
model = BlockedRoom
fields = ('room', 'state', 'rejection_reason', 'rejected_by')
@post_dump(pass_many=True)
def sort_rooms(self, data, many, **kwargs):
if many:
data = sorted(data, key=lambda x: natural_sort_key(x['room']['full_name']))
return data
class AreaSchema(ma.ModelSchema):
class Meta:
fields = (
"areaId",
"areaName",
"areaType",
"electionId",
# "parents",
# "children",
"areaMapList")
model = Area.Model
# optionally attach a Session
# to use for deserialization
sqla_session = db.session
areaType = EnumField(AreaTypeEnum)
electorateType = EnumField(ElectorateTypeEnum)
# parents = ma.Nested('self', only="areaId", many=True)
children = ma.Nested('AreaAreaSchema', only="childAreaId", many=True)
parents = ma.Nested('AreaAreaSchema', only="parentAreaId", many=True)
areaMapList = ma.Nested('AreaMapSchema', many=True, partial=True)
class IncidentSchema(ma.SQLAlchemyAutoSchema):
gender = EnumField(Gender_Enum)
race = EnumField(Race_Enum)
victim_weapon = EnumField(Victim_Weapon_Enum)
victim_action = EnumField(Victim_Action_Enum)
cause_of_death = EnumField(Cause_Of_Death_Enum)
status = EnumField(Status_Enum)
initial_reason_for_encounter = EnumField(Initial_Encounter_Enum)
class Meta:
model = Incidents
class _EnvironmentExecutionStepSchema(BaseSchema):
id = fields.UUID(required=True)
command = fields.List(fields.String(), required=True)
status = EnumField(EnvironmentExecutionStepStatus,
by_value=True,
required=True)
started_at = fields.DateTime(data_key="startedAt", missing=None)
finished_at = fields.DateTime(data_key="finishedAt", missing=None)
@post_load
def make_environment_execution_step(self, data, **kwargs):
return EnvironmentExecutionStep(**data)
class AttachmentSchema(Schema):
url = fields.String(required=True)
type = EnumField(AttachmentType, by_value=True, required=False)
def on_bind_field(self, field_name, field_obj):
field_obj.data_key = camelcase(field_obj.data_key or field_name)
@post_load
def make_attachment(self, data, **kwargs):
return Attachment(**data)
class Meta:
unknown = EXCLUDE
class WorkbenchRate(IndividualRate):
processor = Float()
ram = Float()
data_storage = Float()
graphic_card = Float()
labelling = Boolean(
description='Sets if there are labels stuck that should be removed.')
bios = EnumField(
Bios,
description='How difficult it has been to set the bios to '
'boot from the network.')
appearance_range = EnumField(
AppearanceRange,
required=True,
data_key='appearanceRange',
description='Grades the imperfections that aesthetically '
'affect the device, but not its usage.')
functionality_range = EnumField(
FunctionalityRange,
required=True,
data_key='functionalityRange',
description='Grades the defects of a device that affect its usage.')
class FileSchema(ma.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",
"categories", "description", "category", "description",
"download_name"
]
unknown = INCLUDE
type = EnumField(FileType)
class ResourceSchema(PermissiveSchema):
type = EnumField(GuestTokenResourceType, by_value=True, required=True)
id = fields.String(required=True)
@post_load
def convert_enum_to_value( # pylint: disable=no-self-use
self,
data: Dict[str, Any],
**kwargs: Any # pylint: disable=unused-argument
) -> Dict[str, Any]:
# we don't care about the enum, we want the value inside
data["type"] = data["type"].value
return data
class TourSchema(SQLAlchemyAutoSchema):
class Meta:
model = Tour
load_instance = True
sqla_session = db.session
uuid = fields.UUID(dump_only=True)
upload_time = auto_field(dump_only=True)
duration = fields.TimeDelta(precision='minutes')
location = fields.Nested(Location)
category = EnumField(TourCategory)
guide = fields.Nested(UserSchema)
reviews = fields.Nested(ReviewSchema, many=True)
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')
