Table, Column, UnicodeText, Text, Enum, DateTime ) from sqlalchemy.dialects.postgresql import UUID from sqlalchemy.sql import func from linehaul import db downloads = Table( "downloads", db.metadata, Column( "id", UUID(), primary_key=True, nullable=False, server_default=func.uuid_generate_v4() ), Column("package_name", UnicodeText(), nullable=False), Column("package_version", UnicodeText()), Column( "distribution_type", Enum("sdist", "wheel", "exe", "egg", "msi", name="distribution_type") ), Column( "python_type", Enum("cpython", "pypy", "jython", "ironpython", name="python_type") ), Column("python_release", Text()), Column("python_version", Text()),
class PackageSwitch(BaseModel): __tablename__ = 'package_switch' TYPE = {1: 'switch pay per port', 2: 'switch pay per minute'} SUB_TYPE = {1: 'hosted_switch', 2: 'on_premise', 3: 'one_time'} package_switch_uuid = Column \ (String(36), primary_key=True, default=generate_uuid_str(), server_default=func.uuid_generate_v4()) package_name = Column(String(64), unique=True) type = Column(ChoiceType(TYPE), default=1) sub_type = Column(ChoiceType(SUB_TYPE), nullable=True) #switch_uuid = Column(String(128),index=True) #Column(ForeignKey('switch.switch_uuid', ondelete='CASCADE'), index=True) switch_port = Column(Integer()) minute_count = Column(Integer()) amount = Column(Integer()) enabled = Column(Boolean, default=True) start_date = Column(DateTime(True), nullable=False, server_default=func.now()) expire_date = Column(DateTime(True), nullable=True) create_on = Column(DateTime(True), nullable=True, server_default=func.now()) licenses = relationship('LicenseSwitch', uselist=True, back_populates='package') #switch = relationship('Switch', uselist=False, back_populates='packages') rate_per_port = column_property( case([(switch_port > 0, cast(amount, Float).op('/')(switch_port))], else_=None))
class CorCountingOccurrence(DB.Model): __tablename__ = "cor_counting_occtax" __table_args__ = {"schema": "pr_occtax"} id_counting_occtax = DB.Column(DB.Integer, primary_key=True) unique_id_sinp_occtax = DB.Column(UUID(as_uuid=True), default=select([func.uuid_generate_v4() ]), nullable=False) id_occurrence_occtax = DB.Column( DB.Integer, ForeignKey("pr_occtax.t_occurrences_occtax.id_occurrence_occtax"), nullable=False, ) id_nomenclature_life_stage = DB.Column(DB.Integer, nullable=False) id_nomenclature_sex = DB.Column(DB.Integer, nullable=False) id_nomenclature_obj_count = DB.Column(DB.Integer, nullable=False) id_nomenclature_type_count = DB.Column(DB.Integer) count_min = DB.Column(DB.Integer) count_max = DB.Column(DB.Integer) readonly_fields = [ "id_counting_occtax", "unique_id_sinp_occtax", "id_occurrence_occtax", ] medias = DB.relationship( TMedias, primaryjoin= ('TMedias.uuid_attached_row == CorCountingOccurrence.unique_id_sinp_occtax' ), foreign_keys=[TMedias.uuid_attached_row], cascade="all", lazy="select", )
class TMedias(DB.Model): __tablename__ = "t_medias" __table_args__ = {"schema": "gn_commons"} id_media = DB.Column(DB.Integer, primary_key=True) id_nomenclature_media_type = DB.Column( DB.Integer # , # ForeignKey('ref_nomenclatures.t_nomenclatures.id_nomenclature') ) id_table_location = DB.Column( DB.Integer, ForeignKey("gn_commons.bib_tables_location.id_table_location") ) unique_id_media = DB.Column( UUID(as_uuid=True), default=select([func.uuid_generate_v4()]) ) uuid_attached_row = DB.Column(UUID(as_uuid=True)) title_fr = DB.Column(DB.Unicode) title_en = DB.Column(DB.Unicode) title_it = DB.Column(DB.Unicode) title_es = DB.Column(DB.Unicode) title_de = DB.Column(DB.Unicode) media_url = DB.Column(DB.Unicode) media_path = DB.Column(DB.Unicode) author = DB.Column(DB.Unicode) description_fr = DB.Column(DB.Unicode) description_en = DB.Column(DB.Unicode) description_it = DB.Column(DB.Unicode) description_es = DB.Column(DB.Unicode) description_de = DB.Column(DB.Unicode) is_public = DB.Column(DB.Boolean, default=True)
class Assessment(db.Model): __tablename__ = 'assessments' id = db.Column(UUID(), primary_key=True, default=uuid4, server_default=func.uuid_generate_v4(), index=True, comment='ID оценки') rating = db.Column(db.Float(), nullable=True, comment='Рейтинг фотографии.') photo_id = db.Column(UUID(), db.ForeignKey('photos.id', ondelete='CASCADE'), nullable=True, index=True, comment='ID фотографии.') user_id = db.Column(UUID(), db.ForeignKey('users.id', ondelete='CASCADE'), nullable=True, index=True, comment='ID пользователя.')
class TransactionLog(BaseModel): __tablename__ = 'transaction_log' TYPE = {1: 'paypal', 2: 'stripe'} STATUS = {1: 'success', -1: 'fail'} transaction_log_uuid = Column(String(36), primary_key=True, default=generate_uuid_str(), server_default=func.uuid_generate_v4()) transaction_time = Column(DateTime(True), nullable=False, server_default=func.now()) license_lrn_uuid = Column(String(36)) license_switch_uuid = Column(String(36)) user_uuid = Column(ForeignKey('user.user_uuid', ondelete='CASCADE'), nullable=True, index=True) type = Column(ChoiceType(TYPE), default=1) amount_total = Column(Numeric, nullable=False, server_default='0') amount_lrn = Column(Numeric, nullable=False, server_default='0') amount_switch = Column(Numeric, nullable=False, server_default='0') transaction_fee = Column(Numeric, nullable=False, server_default='0') transaction_id = Column(String(255)) transaction_type = Column(String(255)) from_ip = Column(String(36)) transaction_src = Column(JSON()) status = Column(ChoiceType(STATUS), default=-1) result = Column(Text()) payment_uuid = Column(ForeignKey('payment.payment_uuid', ondelete='CASCADE'), index=True) user_name = column_property( select([User.name ]).where(user_uuid == User.user_uuid).correlate_except(User))
class TBaseVisits(DB.Model): ''' Table de centralisation des visites liées à un site ''' __tablename__ = 't_base_visits' __table_args__ = {'schema': 'gn_monitoring'} id_base_visit = DB.Column(DB.Integer, primary_key=True) id_base_site = DB.Column( DB.Integer, ForeignKey('gn_monitoring.t_base_sites.id_base_site')) id_digitiser = DB.Column(DB.Integer, ForeignKey('utilisateurs.t_roles.id_role')) visit_date_min = DB.Column(DB.DateTime) visit_date_max = DB.Column(DB.DateTime) # geom = DB.Column(Geometry('GEOMETRY', 4326)) comments = DB.Column(DB.DateTime) uuid_base_visit = DB.Column(UUID(as_uuid=True), default=select([func.uuid_generate_v4()])) digitiser = relationship(User, primaryjoin=(User.id_role == id_digitiser), foreign_keys=[id_digitiser]) observers = DB.relationship( User, secondary=corVisitObserver, primaryjoin=(corVisitObserver.c.id_base_visit == id_base_visit), secondaryjoin=(corVisitObserver.c.id_role == User.id_role), foreign_keys=[ corVisitObserver.c.id_base_visit, corVisitObserver.c.id_role ])
class TBaseVisits(DB.Model): """ Table de centralisation des visites liées à un site """ __tablename__ = "t_base_visits" __table_args__ = {"schema": "gn_monitoring"} id_base_visit = DB.Column(DB.Integer, primary_key=True) id_base_site = DB.Column( DB.Integer, ForeignKey("gn_monitoring.t_base_sites.id_base_site") ) id_digitiser = DB.Column( DB.Integer, ForeignKey("utilisateurs.t_roles.id_role") ) id_dataset = DB.Column( DB.Integer, ForeignKey("gn_meta.t_datasets.id_dataset") ) # Pour le moment non défini comme une clé étrangère # pour les questions de perfs # a voir en fonction des usage id_module = DB.Column(DB.Integer) visit_date_min = DB.Column(DB.DateTime) visit_date_max = DB.Column(DB.DateTime) id_nomenclature_tech_collect_campanule = DB.Column(DB.Integer) id_nomenclature_grp_typ = DB.Column(DB.Integer) comments = DB.Column(DB.DateTime) uuid_base_visit = DB.Column( UUID(as_uuid=True), default=select([func.uuid_generate_v4()]) ) meta_create_date = DB.Column(DB.DateTime) meta_update_date = DB.Column(DB.DateTime) digitiser = relationship( User, primaryjoin=(User.id_role == id_digitiser), foreign_keys=[id_digitiser] ) observers = DB.relationship( User, secondary=corVisitObserver, primaryjoin=(corVisitObserver.c.id_base_visit == id_base_visit), secondaryjoin=(corVisitObserver.c.id_role == User.id_role), foreign_keys=[corVisitObserver.c.id_base_visit, corVisitObserver.c.id_role], ) dataset = relationship( TDatasets, lazy="joined", primaryjoin=(TDatasets.id_dataset == id_dataset), foreign_keys=[id_dataset] )
class MyModel(DB.Model): __tablename__ = "my_table" __table_args__ = {"schema": "my_schema"} my_pk = DB.Column(DB.Integer, primary_key=True) my_field = DB.Column( UUID(as_uuid=True), default=select([func.uuid_generate_v4()]) ) geom_local = DB.Column( Geometry("GEOMETRY", current_app.config["LOCAL_SRID"]))
def upgrade(): op.create_table( 'downloads', sa.Column( 'id', postgresql.UUID(), server_default=func.uuid_generate_v4(), nullable=False ), sa.Column('package_name', sa.UnicodeText(), nullable=False), sa.Column('package_version', sa.UnicodeText(), nullable=True), sa.Column( 'distribution_type', sa.Enum( u'sdist', u'wheel', u'exe', u'egg', u'msi', name='distribution_type' ), nullable=True ), sa.Column( 'python_type', sa.Enum( u'cpython', u'pypy', u'jython', u'ironpython', name='python_type' ), nullable=True ), sa.Column('python_release', sa.Text(), nullable=True), sa.Column('python_version', sa.Text(), nullable=True), sa.Column( 'installer_type', sa.Enum( u'browser', u'pip', u'setuptools', u'distribute', u'bandersnatch', u'z3c.pypimirror', u'pep381client', name='installer_type' ), nullable=True ), sa.Column('installer_version', sa.Text(), nullable=True), sa.Column('operating_system', sa.Text(), nullable=True), sa.Column('operating_system_version', sa.Text(), nullable=True), sa.Column('download_time', sa.DateTime(), nullable=False), sa.Column('raw_user_agent', sa.Text(), nullable=False), sa.PrimaryKeyConstraint('id') )
class User(Base): """This model represents an application user.""" __tablename__ = 'user' id = sa.Column(pg.UUID, primary_key=True, server_default=func.uuid_generate_v4()) username = sa.Column(sa.Text, nullable=False, unique=True) password_hash = sa.Column(pg.BYTEA, nullable=False)
class TBaseSites(DB.Model): """ Table centralisant les données élémentaire des sites """ __tablename__ = "t_base_sites" __table_args__ = {"schema": "gn_monitoring"} id_base_site = DB.Column(DB.Integer, primary_key=True) id_inventor = DB.Column( DB.Integer, ForeignKey("utilisateurs.t_roles.id_role") ) id_digitiser = DB.Column( DB.Integer, ForeignKey("utilisateurs.t_roles.id_role") ) id_nomenclature_type_site = DB.Column(DB.Integer) base_site_name = DB.Column(DB.Unicode) base_site_description = DB.Column(DB.Unicode) base_site_code = DB.Column(DB.Unicode) first_use_date = DB.Column(DB.DateTime) geom = DB.Column(Geometry("GEOMETRY", 4326)) uuid_base_site = DB.Column( UUID(as_uuid=True), default=select([func.uuid_generate_v4()]) ) meta_create_date = DB.Column(DB.DateTime) meta_update_date = DB.Column(DB.DateTime) digitiser = relationship( User, primaryjoin=(User.id_role == id_digitiser), foreign_keys=[id_digitiser] ) inventor = relationship( User, primaryjoin=(User.id_role == id_inventor), foreign_keys=[id_inventor] ) t_base_visits = relationship( "TBaseVisits", lazy="select", cascade="all,delete-orphan" ) modules = DB.relationship( "TModules", lazy="select", enable_typechecks=False, secondary=corSiteModule, primaryjoin=(corSiteModule.c.id_base_site == id_base_site), secondaryjoin=(corSiteModule.c.id_module == TModules.id_module), foreign_keys=[corSiteModule.c.id_base_site, corSiteModule.c.id_module], ) def get_geofeature(self, recursif=True): return self.as_geofeature("geom", "id_base_site", recursif)
class Photo(db.Model): __tablename__ = 'photos' id = db.Column(UUID(), primary_key=True, default=uuid4, server_default=func.uuid_generate_v4(), index=True, comment='Id photo.') # noqa path = db.Column(db.String(), nullable=False, comment='Путь до фотографии') # noqa
class Switch(BaseModel): __tablename__ = 'switch' switch_uuid = Column \ (String(36), primary_key=True, default=generate_uuid_str(), server_default=func.uuid_generate_v4()) switch_ip = Column(String(16)) enabled = Column(Boolean, default=True) current_port_count = Column(Integer()) minute_remaining = Column(Integer()) expired_on = Column(DateTime(True), nullable=True) email = Column(String(256))
class BibOrganismes(DB.Model): __tablename__ = "bib_organismes" __table_args__ = {"schema": "utilisateurs", "extend_existing": True} id_organisme = DB.Column(DB.Integer, primary_key=True) uuid_organisme = DB.Column(UUID(as_uuid=True), default=select([func.uuid_generate_v4()])) nom_organisme = DB.Column(DB.Unicode) cp_organisme = DB.Column(DB.Unicode) ville_organisme = DB.Column(DB.Unicode) tel_organisme = DB.Column(DB.Unicode) fax_organisme = DB.Column(DB.Unicode) email_organisme = DB.Column(DB.Unicode)
class TBaseSites(DB.Model): ''' Table centralisant les données élémentaire des sites ''' __tablename__ = 't_base_sites' __table_args__ = {'schema': 'gn_monitoring'} id_base_site = DB.Column(DB.Integer, primary_key=True) id_inventor = DB.Column( DB.Integer, ForeignKey('utilisateurs.t_roles.id_role') ) id_digitiser = DB.Column( DB.Integer, ForeignKey('utilisateurs.t_roles.id_role') ) id_nomenclature_type_site = DB.Column(DB.Integer) base_site_name = DB.Column(DB.Unicode) base_site_description = DB.Column(DB.Unicode) base_site_code = DB.Column(DB.Unicode) first_use_date = DB.Column(DB.DateTime) geom = DB.Column(Geometry('GEOMETRY', 4326)) uuid_base_site = DB.Column( UUID(as_uuid=True), default=select([func.uuid_generate_v4()]) ) digitiser = relationship("TRoles", foreign_keys=[id_digitiser]) inventor = relationship("TRoles", foreign_keys=[id_digitiser]) t_base_visits = relationship( "TBaseVisits", lazy='joined', cascade="all,delete-orphan" ) applications = DB.relationship( 'TApplications', secondary=corSiteApplication, primaryjoin=( corSiteApplication.c.id_base_site == id_base_site ), secondaryjoin=( corSiteApplication.c.id_application == TApplications.id_application ), foreign_keys=[ corSiteApplication.c.id_base_site, corSiteApplication.c.id_application ] ) def get_geofeature(self, recursif=True): return self.as_geofeature('geom_4326', 'id_base_site', recursif)
class Payment(BaseModel): __tablename__ = 'payment' TYPE = {1: 'paypal', 2: 'stripe'} payment_uuid = Column(String(36), primary_key=True, default=generate_uuid_str(), server_default=func.uuid_generate_v4()) user_uuid = Column(ForeignKey('user.user_uuid', ondelete='CASCADE'), index=True) license_lrn_uuid = Column(ForeignKey('license_lrn.license_lrn_uuid', ondelete='CASCADE'), nullable=True, index=True) license_switch_uuid = Column(ForeignKey( 'license_switch.license_switch_uuid', ondelete='CASCADE'), nullable=True, index=True) switch_uuid = Column(String(64), index=True) amount_lrn = Column(Numeric, nullable=False, server_default='0') amount_switch = Column(Numeric, nullable=False, server_default='0') #amount_total = Column(Numeric, nullable=False, server_default='0') paid_time = Column(DateTime(True), nullable=False, server_default=func.now()) type = Column(ChoiceType(TYPE), default=1) description = Column(Text) user = relationship('User') amount_total = column_property(amount_lrn.op('+')(amount_switch)) user_email = column_property( select([User.email ]).where(User.user_uuid == user_uuid).correlate_except(User)) @property def license_uuid(self): if self.license_lrn_uuid: return self.license_lrn_uuid if self.license_switch_uuid: return self.license_switch_uuid return None @property def license(self): if self.license_lrn_uuid: return LicenseLrn.get(self.license_lrn_uuid) if self.license_switch_uuid: return LicenseSwitch.get(self.license_switch_uuid) return None def apply_mail(self, template_name): return _apply_mail(self, template_name, 'payment')
class Plan(BaseModel): __tablename__ = 'plan' TYPE = { 1: 'switch pay per port', 2: 'switch pay per minute', 3: 'LRN pay per CPS', 4: 'LRN pay per DIP' } plan_uuid = Column(String(36), primary_key=True, default=generate_uuid_str(), server_default=func.uuid_generate_v4()) type = Column(ChoiceType(TYPE), default=1) amount = Column(Numeric, nullable=False, server_default='0')
class Account(Base, Timestamp): """A bank account.""" __tablename__ = 'accounts' id = Column(UUID(as_uuid=True), primary_key=True, server_default=func.uuid_generate_v4()) iban = Column(String(34), nullable=False, unique=True, index=True) bic = Column(String(11), nullable=False, index=True) def __init__(self, iban: str, bic: str): self.iban = iban self.bic = bic def __repr__(self): return f"<Account {self.id} with IBAN {self.iban}>"
class Transaction(Base, Timestamp): """A single transaction.""" __tablename__ = 'transactions' id = Column(UUID(as_uuid=True), primary_key=True, server_default=func.uuid_generate_v4()) account_id = Column(UUID(as_uuid=True), ForeignKey('accounts.id'), nullable=False, index=True) account = relationship('Account', backref=backref('transctions', cascade='all, delete-orphan')) def __init__(self, iban, bic): self.iban = iban self.bic = bic def __repr__(self): return f"{self.iban} {self.bic}"
class CorCountingOccurrence(DB.Model): __tablename__ = "cor_counting_occtax" __table_args__ = {"schema": "pr_occtax"} id_counting_occtax = DB.Column(DB.Integer, primary_key=True) unique_id_sinp_occtax = DB.Column(UUID(as_uuid=True), default=select([func.uuid_generate_v4() ])) id_occurrence_occtax = DB.Column( DB.Integer, ForeignKey("pr_occtax.t_occurrences_occtax.id_occurrence_occtax")) id_nomenclature_life_stage = DB.Column(DB.Integer) id_nomenclature_sex = DB.Column(DB.Integer) id_nomenclature_obj_count = DB.Column(DB.Integer) id_nomenclature_type_count = DB.Column(DB.Integer) count_min = DB.Column(DB.Integer) count_max = DB.Column(DB.Integer)
class User(db.Model): __tablename__ = 'users' __hiden_keys__ = ('password', ) id = db.Column(UUID(), primary_key=True, default=uuid4, server_default=func.uuid_generate_v4(), comment='ID пользователя') # noqa login = db.Column(db.String(), nullable=False, comment='Логин пользователя') # noqa password = db.Column(db.LargeBinary(), nullable=False, comment='Пароль пользователя') # noqa
class TOccurrencesOccurrence(DB.Model): __tablename__ = "t_occurrences_occtax" __table_args__ = {"schema": "pr_occtax"} id_occurrence_occtax = DB.Column(DB.Integer, primary_key=True) id_releve_occtax = DB.Column( DB.Integer, ForeignKey("pr_occtax.t_releves_occtax.id_releve_occtax")) id_nomenclature_obs_technique = DB.Column(DB.Integer) id_nomenclature_bio_condition = DB.Column(DB.Integer) id_nomenclature_bio_status = DB.Column(DB.Integer) id_nomenclature_naturalness = DB.Column(DB.Integer) id_nomenclature_exist_proof = DB.Column(DB.Integer) id_nomenclature_observation_status = DB.Column(DB.Integer) id_nomenclature_blurring = DB.Column(DB.Integer) id_nomenclature_source_status = DB.Column(DB.Integer) determiner = DB.Column(DB.Unicode) id_nomenclature_determination_method = DB.Column(DB.Integer) id_nomenclature_behaviour = DB.Column(DB.Integer) cd_nom = DB.Column(DB.Integer, ForeignKey(Taxref.cd_nom)) nom_cite = DB.Column(DB.Unicode) meta_v_taxref = DB.Column( DB.Unicode, default=select( [func.gn_commons.get_default_parameter("taxref_version")]), ) sample_number_proof = DB.Column(DB.Unicode) digital_proof = DB.Column(DB.Unicode) non_digital_proof = DB.Column(DB.Unicode) comment = DB.Column(DB.Unicode) #additional fields dans occtax MET 28/09/2020 additional_fields = DB.Column(JSONB) unique_id_occurence_occtax = DB.Column( UUID(as_uuid=True), default=select([func.uuid_generate_v4()]), ) cor_counting_occtax = relationship( "CorCountingOccurrence", lazy="joined", cascade="all,delete-orphan", uselist=True, backref=DB.backref("occurence", lazy="joined"), ) taxref = relationship(Taxref, lazy="joined") readonly_fields = ["id_occurrence_occtax", "id_releve_occtax", "taxref"]
class Notification(BaseModel, ModelUsingFiles): __tablename__ = 'notification' notification_uuid = Column(String(36), primary_key=True, default=generate_uuid_str(), server_default=func.uuid_generate_v4()) user_uuid = Column(ForeignKey('user.user_uuid', ondelete='CASCADE'), nullable=True, index=True) subject = Column(String(64), nullable=False) content = Column(Text, nullable=False) created_on = Column(DateTime(True), nullable=False, server_default=func.now()) user = relationship('User')
class BaseModel(db.Model): __abstract__ = True id = db.Column(UUID(), primary_key=True, default=uuid4, server_default=func.uuid_generate_v4(), comment='ID') create_datetime = db.Column(db.DateTime(), nullable=False, default=datetime.utcnow, server_default=func.now(), comment='UTC create datetime') update_datetime = db.Column(db.DateTime(), nullable=False, default=datetime.utcnow, server_default=func.now(), comment='UTC update datetime')
def pk(*foreign_key_column_names: str) -> sa.Column: """A UUID primary key. Return a standard primary key of type UUID for use in models. If the any foreign_key_column_names are supplied, the primary key will reference the given columns. :param foreign_key_column_names: column names of the referenced foreign keys (should be 'table_name.column_name') :return: a SQLAlchemy Column for a UUID primary key. """ args = [pg.UUID] args.extend(map(fk, foreign_key_column_names)) kwargs = { 'primary_key': True, 'server_default': func.uuid_generate_v4(), } return sa.Column(*args, **kwargs)
class PackageLrn(BaseModel): __tablename__ = 'package_lrn' TYPE = {3: 'LRN pay per CPS', 4: 'LRN pay per DIP'} package_lrn_uuid = Column \ (String(36), primary_key=True, default=generate_uuid_str(), server_default=func.uuid_generate_v4()) package_name = Column(String(64), unique=True) cps = Column(Integer()) type = Column(ChoiceType(TYPE), default=3) lrn_port = Column(Integer()) dip_count = Column(Integer()) amount = Column(Integer()) enabled = Column(Boolean, default=True) licenses = relationship('LicenseLrn', uselist=True, back_populates='package') create_on = Column(DateTime(True), nullable=True, server_default=func.now())
def upgrade(): op.create_table( 'downloads', sa.Column('id', postgresql.UUID(), server_default=func.uuid_generate_v4(), nullable=False), sa.Column('package_name', sa.UnicodeText(), nullable=False), sa.Column('package_version', sa.UnicodeText(), nullable=True), sa.Column('distribution_type', sa.Enum(u'sdist', u'wheel', u'exe', u'egg', u'msi', name='distribution_type'), nullable=True), sa.Column('python_type', sa.Enum(u'cpython', u'pypy', u'jython', u'ironpython', name='python_type'), nullable=True), sa.Column('python_release', sa.Text(), nullable=True), sa.Column('python_version', sa.Text(), nullable=True), sa.Column('installer_type', sa.Enum(u'browser', u'pip', u'setuptools', u'distribute', u'bandersnatch', u'z3c.pypimirror', u'pep381client', name='installer_type'), nullable=True), sa.Column('installer_version', sa.Text(), nullable=True), sa.Column('operating_system', sa.Text(), nullable=True), sa.Column('operating_system_version', sa.Text(), nullable=True), sa.Column('download_time', sa.DateTime(), nullable=False), sa.Column('raw_user_agent', sa.Text(), nullable=False), sa.PrimaryKeyConstraint('id'))
class Bib_Organismes(GenericRepository): """ Model de la table Bib_Organismes """ __tablename__ = 'bib_organismes' __table_args__ = {'schema': 'utilisateurs'} id_organisme = db.Column(db.Integer, primary_key=True) uuid_organisme = db.Column(UUID(as_uuid=True), default=select([func.uuid_generate_v4()])) nom_organisme = db.Column(db.Unicode) adresse_organisme = db.Column(db.Unicode) cp_organisme = db.Column(db.Unicode) ville_organisme = db.Column(db.Unicode) tel_organisme = db.Column(db.Unicode) fax_organisme = db.Column(db.Unicode) email_organisme = db.Column(db.Unicode) url_organisme = db.Column(db.Unicode) url_logo = db.Column(db.Unicode) id_parent = db.Column(db.Integer)
class corRoleRelevesOccurrence(DB.Model): __tablename__ = "cor_role_releves_occtax" __table_args__ = {"schema": "pr_occtax"} unique_id_cor_role_releve = DB.Column( "unique_id_cor_role_releve", UUID(as_uuid=True), default=select([func.uuid_generate_v4()]), primary_key=True, ) id_releve_occtax = DB.Column( "id_releve_occtax", DB.Integer, ForeignKey("pr_occtax.t_releves_occtax.id_releve_occtax"), primary_key=False, ) id_role = DB.Column( "id_role", DB.Integer, ForeignKey("utilisateurs.t_roles.id_role"), primary_key=False, )
class Balance(Base, Timestamp): """An immutable account balance at a certain point in time. Account balances may not be updated once they are created. """ __tablename__ = 'balances' id = Column(UUID(as_uuid=True), primary_key=True, server_default=func.uuid_generate_v4()) balance = Column(Numeric(), nullable=False, index=True) currency = Column(String(3), nullable=False, index=True) account_id = Column(UUID(as_uuid=True), ForeignKey('accounts.id'), nullable=False, index=True) account = relationship('Account', backref=backref('balances', cascade='all, delete-orphan')) def __init__(self, balance: str, currency: str, account: Account): self.balance = Decimal(balance) self.currency = currency self.account = account def __repr__(self): return f"<Balance {self.id} at {self.created_at} ({self.balance} {self.currency})"
class THabitatsOcchab(DB.Model): __tablename__ = "t_habitats" __table_args__ = {"schema": "pr_occhab"} id_habitat = DB.Column(DB.Integer, primary_key=True) id_station = DB.Column(DB.Integer, ForeignKey("pr_occhab.t_stations.id_station")) unique_id_sinp_hab = DB.Column(UUID(as_uuid=True), default=select([func.uuid_generate_v4()])) cd_hab = DB.Column(DB.Integer, ForeignKey('ref_habitats.habref.cd_hab')) nom_cite = DB.Column(DB.Unicode) id_nomenclature_determination_type = DB.Column( DB.Integer, ForeignKey(TNomenclatures.id_nomenclature)) determiner = DB.Column(DB.Unicode) id_nomenclature_collection_technique = DB.Column( DB.Integer, ForeignKey(TNomenclatures.id_nomenclature)) recovery_percentage = DB.Column(DB.Float) id_nomenclature_abundance = DB.Column( DB.Integer, ForeignKey(TNomenclatures.id_nomenclature)) technical_precision = DB.Column(DB.Unicode) id_nomenclature_sensitvity = DB.Column(DB.Integer) habref = DB.relationship("Habref", lazy="joined")
- user : a TRole object - user_cruved: object return by cruved_for_user_in_app(user) """ return { action: self.user_is_allowed_to(user, level) for action, level in user_cruved.items() } corRoleRelevesOccurrence = DB.Table( "cor_role_releves_occtax", DB.MetaData(schema="pr_occtax"), DB.Column( "unique_id_cor_role_releve", UUID(as_uuid=True), default=select([func.uuid_generate_v4()]), primary_key=True, ), DB.Column( "id_releve_occtax", DB.Integer, ForeignKey("pr_occtax.t_releves_occtax.id_releve_occtax"), primary_key=False, ), DB.Column( "id_role", DB.Integer, ForeignKey("utilisateurs.t_roles.id_role"), primary_key=False, ), )