class RoleSchema(SQLAlchemySchema): """Role item schema""" class Meta: """Meta""" model = Role name = auto_field() permissions = fields.List(fields.Nested(ActionResourceSchema), data_key='actions')
class UserCollectionItemSchema(SQLAlchemySchema): """user collection item schema""" class Meta: """Meta""" model = User dateformat = "iso" first_name = auto_field() last_name = auto_field() username = auto_field() active = auto_field(dump_only=True) email = auto_field() last_login = auto_field(dump_only=True) login_count = auto_field(dump_only=True) fail_login_count = auto_field(dump_only=True) roles = fields.List(fields.Nested(RoleSchema, only=('name', ))) created_on = auto_field(validate=validate_istimezone, dump_only=True) changed_on = auto_field(validate=validate_istimezone, dump_only=True)
class LogFullFixture(FixtureSchema): class Meta(FixtureSchema.Meta): model = TLog filter_attrs = ["sLog"] sLog = auto_field() user = Nested(UserFixture, many=False) fields = Nested(FieldFixture, many=True) user_permissions = Nested(UserPermissionFixture) role_permissions = Nested(RolePermissionFixture)
class TickerSchema(ma.SQLAlchemySchema): class Meta: model = Ticker render_module = simplejson currency_code = fields.String(validate=validate_currency) currency_rate = fields.Decimal(validate=validate_decimal) amount_requested = fields.Decimal(validate=validate_decimal) final_amount = fields.Decimal(validate=validate_decimal) created_at = auto_field(dump_only=True)
class TargetSchema(SQLAlchemyAutoSchema): class Meta(BaseSchema.Meta): model = db_models.Target exclude = () unknown = EXCLUDE # todo: sort this out # It's possible to define defaults here. However, default here would require aditional default functions, as None is # considered valid value by Marshmallow does not trigger default/missing. protocol = EnumField(sslyze.ssl_settings.TlsWrappedProtocolEnum) id = auto_field(dump_only=True)
class PoolSchema(SQLAlchemySchema): """Pool schema""" class Meta: """Meta""" model = Pool load_instance = True exclude = ("pool", ) name = auto_field("pool") slots = auto_field() occupied_slots = fields.Method("get_occupied_slots", dump_only=True) running_slots = fields.Method("get_running_slots", dump_only=True) queued_slots = fields.Method("get_queued_slots", dump_only=True) open_slots = fields.Method("get_open_slots", dump_only=True) @staticmethod def get_occupied_slots(obj: Pool) -> int: """ Returns the occupied slots of the pool. """ return obj.occupied_slots() @staticmethod def get_running_slots(obj: Pool) -> int: """ Returns the running slots of the pool. """ return obj.running_slots() @staticmethod def get_queued_slots(obj: Pool) -> int: """ Returns the queued slots of the pool. """ return obj.queued_slots() @staticmethod def get_open_slots(obj: Pool) -> int: """ Returns the open slots of the pool. """ return obj.open_slots()
class ImageFileSchema(SQLAlchemySchema): """ image file model schema """ class Meta: """ meta class """ model = ImageFile load_instance = True sqla_session = db.session id = auto_field() created = auto_field() name = fields.String(required=True) file_path = fields.String(load_only=True) url = fields.Function( lambda obj: os.path.join(current_app.config['HOST'], current_app. config['STATIC_URL'], obj.file_path))
class EpisodeSchema(SQLAlchemySchema): class Meta: model = Episode load_instance = True id = auto_field() show_id = auto_field() share_link = auto_field() iframe = auto_field() title = auto_field() description = auto_field() image = auto_field() tracklist = auto_field()
class ContactSchema(SQLAlchemySchema): class Meta: model = Contact load_instance = True contact_id = auto_field() project_id = auto_field() name = auto_field() link = auto_field() checked = auto_field() in_contact = auto_field() notes = auto_field() active = auto_field()
class InventorySchema(SQLAlchemyAutoSchema): class Meta: model = Inventory include_fk = True exclude = ['value_of_materials'] value_of_materials = auto_field(dump_only=True) # Override materials field to use a nested representation rather than pks material = Nested(lambda: MaterialSchema(), dump_only=True) place = Nested(lambda: PlaceSchema(), dump_only=True)
class BandForm(SQLAlchemyAutoSchema): """Represent the BDC-Catalog Band model.""" collection_id = auto_field() class Meta: """Internal meta information of form interface.""" model = Band sqla_session = db.session exclude = []
class BoundLimitSchema(SQLAlchemySchema): id = auto_field() limit_id = auto_field() user_id = auto_field() user_group_id = auto_field() scheduler_partition_id = auto_field() refresh_period_days = auto_field() priority = auto_field() is_default = auto_field() is_active = auto_field() class Meta: model = BoundLimit load_instance = True include_relationships = True limit_item = fields.Nested(LimitItemSchema)
class UserSchema(SQLAlchemyAutoSchema): class Meta: model = User sqla_session = db.session load_instance = True password = auto_field(load_only=True) languages = fields.Nested(UserXLanguageSchema, many=True, exclude=("id",)) emergency_contacts = fields.Nested(EmergencyContactSchema, many=True, exclude=('id',)) reviews_of_me = fields.Nested(ReviewSchema, many=True) reviews_by_me = fields.Nested(ReviewSchema, many=True)
class CertificateChainSchemaWithoutCertificates(SQLAlchemyAutoSchema): class Meta(BaseSchema.Meta): model = db_models.CertificateChain exclude = () id = auto_field(dump_only=True) chain_arr = fields.Method("chain_to_propper_arr", dump_only=True) @staticmethod def chain_to_propper_arr(obj): return app.utils.db.basic.split_array_to_tuple(obj.chain)
class DAGSchema(SQLAlchemySchema): """DAG schema""" class Meta: """Meta""" model = DagModel dag_id = auto_field(dump_only=True) root_dag_id = auto_field(dump_only=True) is_paused = auto_field() is_subdag = auto_field(dump_only=True) fileloc = auto_field(dump_only=True) owners = fields.Method("get_owners", dump_only=True) description = auto_field(dump_only=True) schedule_interval = fields.Nested(ScheduleIntervalSchema) tags = fields.List(fields.Nested(DagTagSchema), dump_only=True) @staticmethod def get_owners(obj: DagModel): """Convert owners attribute to DAG representation""" if not getattr(obj, 'owners', None): return [] return obj.owners.split(",")
class DAGRunSchema(SQLAlchemySchema): """Schema for DAGRun""" class Meta: """Meta""" model = DagRun dateformat = "iso" run_id = auto_field(data_key='dag_run_id') dag_id = auto_field(dump_only=True) execution_date = auto_field(validate=validate_istimezone) start_date = auto_field(dump_only=True) end_date = auto_field(dump_only=True) state = DagStateField(dump_only=True) external_trigger = auto_field(default=True, dump_only=True) conf = ConfObject() @pre_load def autogenerate(self, data, **kwargs): """Auto generate run_id and execution_date if they are not loaded""" if "execution_date" not in data.keys(): data["execution_date"] = str(timezone.utcnow()) if "dag_run_id" not in data.keys(): try: data["dag_run_id"] = DagRun.generate_run_id( DagRunType.MANUAL, timezone.parse(data["execution_date"]) ) except (ParserError, TypeError) as err: raise BadRequest("Incorrect datetime argument", detail=str(err)) return data
class DAGSchema(SQLAlchemySchema): """DAG schema""" class Meta: """Meta""" model = DagModel dag_id = auto_field(dump_only=True) root_dag_id = auto_field(dump_only=True) is_paused = auto_field() is_subdag = auto_field(dump_only=True) fileloc = auto_field(dump_only=True) file_token = fields.Method("get_token", dump_only=True) owners = fields.Method("get_owners", dump_only=True) description = auto_field(dump_only=True) schedule_interval = fields.Nested(ScheduleIntervalSchema) tags = fields.List(fields.Nested(DagTagSchema), dump_only=True) @staticmethod def get_owners(obj: DagModel): """Convert owners attribute to DAG representation""" if not getattr(obj, 'owners', None): return [] return obj.owners.split(",") @staticmethod def get_token(obj: DagModel): """Return file token""" serializer = URLSafeSerializer(conf.get('webserver', 'secret_key')) return serializer.dumps(obj.fileloc)
class EventLogSchema(SQLAlchemySchema): """Event log schema""" class Meta: """Meta""" model = Log id = auto_field(data_key='event_log_id', dump_only=True) dttm = auto_field(data_key='when', dump_only=True) dag_id = auto_field(dump_only=True) task_id = auto_field(dump_only=True) event = auto_field(dump_only=True) execution_date = auto_field(dump_only=True) owner = auto_field(dump_only=True) extra = auto_field(dump_only=True)
class DAGRunSchema(SQLAlchemySchema): """ Schema for DAGRun """ class Meta: """Meta""" model = DagRun dateformat = "iso" run_id = auto_field(data_key='dag_run_id') dag_id = auto_field(dump_only=True) execution_date = auto_field() start_date = auto_field(dump_only=True) end_date = auto_field(dump_only=True) state = DagStateField(dump_only=True) external_trigger = auto_field(default=True, dump_only=True) conf = ConfObject() @pre_load def autogenerate(self, data, **kwargs): """ Auto generate run_id and execution_date if they are not loaded """ if "execution_date" not in data.keys(): data["execution_date"] = str(timezone.utcnow()) if "dag_run_id" not in data.keys(): data["dag_run_id"] = DagRun.generate_run_id( DagRunType.MANUAL, timezone.parse(data["execution_date"]) ) 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 StylesheetSchema(DokuSchema, DateSchemaMixin, ApiSchemaMixin): class Meta: model = Stylesheet exclude = ("base_templates", "templates") load_instance = True API_NAME = "template" id = auto_field() name = auto_field() source = auto_field() base_templates = Nested("TemplateSchema", exclude=("base_style", ), many=True) templates = Nested("TemplateSchema", exclude=("styles", ), many=True) upload_url = fields.Method("_upload_url", dump_only=True, allow_none=True) def _upload_url(self, stylesheet) -> Optional[str]: if stylesheet.id is None: return None return url_for("api.v1.stylesheet.upload", stylesheet_id=stylesheet.id)
class LocationSchema(SQLAlchemySchema): class Meta: model = Location id = auto_field() device_id = auto_field() recorded_at = auto_field() location_type = auto_field() longitude = auto_field() latitude = auto_field() altitude = auto_field()
class BulkInvoiceSchema(SQLAlchemySchema): class Meta: model = BulkInvoice # Define the relevant fields for JSON name = fields.Str() title = fields.Str() mailing_list = auto_field() issuing_date = auto_field() update_time = auto_field() due_date = auto_field() status = auto_field() text_invoice = auto_field() text_reminder = auto_field() text_mail = auto_field()
class PostUserSchema(SQLAlchemySchema): class Meta: model = PostUser load_instance = True id = auto_field() info = auto_field() timestamp = auto_field() user_id = auto_field() user_name = auto_field() vehicle_id = auto_field() vehicle_placa = auto_field()
class DatasetSchema(SQLAlchemySchema): class Meta: model = Dataset ordered = True dataset_id = auto_field() name = auto_field() creation_timestamp = auto_field() service_type = auto_field() validity_expiration_timestamp = auto_field() author = auto_field() external = auto_field()
class CollectorSchema(SQLAlchemySchema): class Meta: model = DatasetCollector ordered = True kafka_topic = auto_field(required=True) kafka_server = auto_field(required=True) nsd_id = auto_field(required=True) creation_timestamp = auto_field() termination_timestamp = auto_field() latest_update = auto_field() status = auto_field()
class UserSchema(SQLAlchemySchema): class Meta: model = UserModel load_instance = True id = auto_field() username = auto_field() email = auto_field() verified = auto_field() active = auto_field() first_name = auto_field() last_name = auto_field()
class ShowSchema(SQLAlchemySchema): class Meta: model = Show load_instance = True id = auto_field() title = auto_field() host = auto_field() description = auto_field() bio = auto_field() image = auto_field() tags = auto_field()
class BoundJobRuleSchema(SQLAlchemySchema): id = auto_field() job_rule_id = auto_field() user_id = auto_field() user_group_id = auto_field() scheduler_partition_id = auto_field() priority = auto_field() is_default = auto_field() is_active = auto_field() class Meta: model = BoundJobRule load_instance = True include_relationships = True job_rule = fields.Nested(JobRuleSchema)
class MessageSchema(ma.SQLAlchemyAutoSchema): class Meta: model = Message load_instance = True sqla_session = True author_id = auto_field(load_only=True) author = fields.Nested(lambda: UserSchema(only=("id", "username")), dump_only=True) @validates("author_id") def validate_author_id(self, author_id): user = User.query.get(author_id) if user is None: raise ValidationError("User does not exist") chatroom_id = auto_field(load_only=True) @validates("chatroom_id") def validate_chatroom_id(self, chatroom_id): user = Chatroom.query.get(chatroom_id) if user is None: raise ValidationError("Chatroom does not exist")