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')