class ReportRaw(GenericTable): __tablename__ = "reportraw" __lobs__ = { "ureport": 1 << 32, } id = Column(Integer, primary_key=True) report_id = Column(Integer, ForeignKey("{0}.id".format(Report.__tablename__), ondelete="CASCADE"), index=True, nullable=False) origin = Column(String(256), nullable=True, index=True) report = relationship(Report, backref="raw_reports")
class BzAttachment(GenericTable): __tablename__ = "bzattachments" __lobs__ = {"content": 1 << 24} id = Column(Integer, primary_key=True) bug_id = Column(Integer, ForeignKey("{0}.id".format(BzBug.__tablename__)), nullable=False, index=True) user_id = Column(Integer, ForeignKey("{0}.id".format(BzUser.__tablename__)), nullable=False, index=True) mimetype = Column(String(256), nullable=False) description = Column(String(256), nullable=False) creation_time = Column(DateTime, nullable=False) last_change_time = Column(DateTime, nullable=False) is_private = Column(Boolean, nullable=False) is_patch = Column(Boolean, nullable=False) is_obsolete = Column(Boolean, nullable=False) filename = Column(String(256), nullable=False) bug = relationship(BzBug, backref="attachments") user = relationship(BzUser)
class NotificationAssetImportance(db.Model): __tablename__ = 'notification_asset_importance' user_id = Column(BigInteger, ForeignKey("iot_user.id"), primary_key=True) high = Column(Boolean, nullable=False, default=True) medium = Column(Boolean, nullable=False, default=True) low = Column(Boolean, nullable=False, default=True) def save(self): db.session.add(self) db.session.commit() return self @classmethod def get_with(cls, user_id): return cls.query.get(user_id)
class User(EntityBiz, Base): __tablename__ = 'usr_user' __table_args__ = (UniqueConstraint('login', 'deleted', name='uix_usr_user_login_deleted'), ) login = Column(String, unique=True, nullable=False) password = Column(String, nullable=False) first_name = Column(String) last_name = Column(String) science_degree = Column(String) role_id = Column(INTEGER, ForeignKey('usr_role.id'), nullable=False) role = relationship('Role', backref='Role', lazy='joined', primaryjoin='Role.id == User.role_id') def __init__(self, login, password, first_name, last_name, science_degree, created_by, role_id): EntityBiz.__init__(self, created_by) self.login = login self.password = generate_password_hash(password, 12).decode('utf-8') self.first_name = first_name self.last_name = last_name self.science_degree = science_degree self.role_id = role_id def update(self, first_name, last_name, science_degree, update_by): EntityBiz.update_entity(self, update_by) self.first_name = first_name self.last_name = last_name self.science_degree = science_degree def update_del(self, deleted_by): EntityBiz.update_del_entity(self, deleted_by) def update_role(self, role_id, update_by): EntityBiz.update_entity(self, update_by) self.role_id = role_id def check_password(self, value): if not value and not self.password: return False return check_password_hash(self.password.encode('utf-8'), value.encode('utf-8'))
class Status(Base): metadata = MetaData() __tablename__ = "status_reg" __table_args__ = {"useexisting": True} id = Column('id', BIGINT, primary_key=True) description = Column('description', Text, nullable=False) statustp = Column('statustp', BIGINT, ForeignKey(Type.code), nullable=False) code = Column('code', BIGINT, nullable=False, unique=True) Status_tbl = Table(__tablename__, metadata, id, description, statustp, code) #Relations table_rel_typ = relationship(Type, backref=backref("Status")) def __repr__(self): return "<Status (id='%s', description='%s', statustp='%s', code='%s')>" % \ (self.id, self.description, self.statustp, self.code) def __Publish__(self): data = {} for column in self.__table__.columns.keys(): value = self.__dict__[self.__table__.columns[column].name] if self.__table__.columns[column].type == "BIGINT": data[self.__table__.columns[column].name] = int(value) elif self.__table__.columns[column].type == "Integer": data[self.__table__.columns[column].name] = int(value) elif self.__table__.columns[column].type == "NUMERIC": data[self.__table__.columns[column].name] = float(value) elif self.__table__.columns[column].type == "Decimal": data[self.__table__.columns[column].name] = float(value) elif self.__table__.columns[column].type == "time": data[self.__table__.columns[column].name] = str( value.strftime('%H:%M:%S')) elif self.__table__.columns[column].type == "datetime": data[self.__table__.columns[column].name] = str( value.strftime('%H:%M:%S')) else: data[self.__table__.columns[column].name] = str(value) return data
class Citation(Base): """Model representing citations and their meta data, with links to their tags""" __tablename__ = "citations" id = Column(Integer, primary_key=True) guid = Column(String(36)) text = Column(String) # meta data stored as json string with arbitrary fields # not planning on querying against this, just need it available meta = Column(String) summary_id = Column(Integer, ForeignKey("summaries.id")) summary = relationship("Summary", back_populates="citations") def __repr__(self): return f"Citation(id: {self.id}, text: {self.text}, meta: {self.meta})"
class ProcessStatus(db.Model): __tablename__ = 'process_status' proc_sid = db.Column(db.Integer, primary_key = True) process_id = db.Column(db.Integer, ForeignKey('process_info.process_id')) cpu_usage = db.Column(db.Float) memory_usage = db.Column(db.Float) process_Status = db.Column(db.String(50)) created_at = db.Column(db.String(50)) def __init__(self, cpu_usage, memory_usage, process_Status, created_at): self.cpu_usage = cpu_usage self.memory_usage = memory_usage self.process_Status = process_Status self.created_at = created_at
class ExampleInnerEntity(Model, ExampleInner): uid = Column(Integer, primary_key=True) strMember = Column(String) parentUid = Column(Integer, ForeignKey(ExampleEntity.uid)) def __init__(self, uid=None, strMember='abc'): self.uid = uid self.strMember = strMember def __repr__(self): if self.uid is not None: return 'ExampleInnerEntity[uid=%d, strMember=%s]' % ( self.uid, self.strMember) else: return 'ExampleInnerEntity[uid=none, strMember=%s]' % ( self.strMember)
class ReportComment(GenericTable): __tablename__ = "reportcomments" id = Column(Integer, primary_key=True) report_id = Column(Integer, ForeignKey("{0}.id".format(Report.__tablename__), ondelete="CASCADE"), nullable=False) text = Column(String(1024), nullable=False) saved = Column(DateTime) report = relationship(Report, backref="comments") def to_json(self): return { "saved": self.saved, "text": self.text, }
class Offtime(DbModel): __tablename__ = 'offtimes' id = Column(String(100), primary_key=True) person_id = Column(String(100), ForeignKey("persons.id")) fade_in = Column(DateTime()) start = Column(DateTime()) end = Column(DateTime()) fade_out = Column(DateTime()) def __init__(self, person_id=None, fade_in=None, start=None, end=None, fade_out=None): self.person_id = person_id self.fade_in = datetime.strptime(fade_in,"%Y-%m-%dT%H:%M:%SZ") self.start = datetime.strptime(start,"%Y-%m-%dT%H:%M:%SZ") self.end = datetime.strptime(end,"%Y-%m-%dT%H:%M:%SZ") self.fade_out = datetime.strptime(fade_out,"%Y-%m-%dT%H:%M:%SZ")
class Entity(Base): """Model representing an entity tagged in an annotation.""" __tablename__ = 'entity' id = Column(Integer, primary_key=True) type = Column(String(16)) # PERSON PLACE TIME start_char = Column(Integer) stop_char = Column(Integer) annotated_citation_id = Column(Integer, ForeignKey('annotatedcitation.id')) annotated_citation = relationship('AnnotatedCitation', back_populates='entities') def __repr__(self): return f'Entity(id: {self.id}, type: {self.type}, start_char: {self.start_char}, ' + \ f'stop_char: {self.stop_char})'
class Modulo(Serializable, Base): way = {'roles': {}, 'children': {}} __tablename__ = 'cb_usuarios_modulo' __table_args__ = ({"schema": "ASISTENCIA"}) id = Column(Integer, Sequence('id'), primary_key=True) route = Column(String(100)) title = Column(String(100), nullable=False) name = Column(String(100), nullable=False, unique=True) icon = Column(String(50), nullable=False, default='home.ico') menu = Column(Boolean, nullable=False, default=True) fkmodulo = Column(Integer, ForeignKey('ASISTENCIA.cb_usuarios_modulo.id')) roles = relationship('Rol', secondary=Acceso) children = relationship('Modulo')
class Idioma(Serializable, Base): way = {'persona': {}} __tablename__ = 'cb_rrhh_persona_idioma' __table_args__ = ({"schema": "ASISTENCIA"}) id = Column(Integer, Sequence('id'), primary_key=True) fkpersona = Column(Integer, ForeignKey("ASISTENCIA.cb_rrhh_persona.id")) idioma = Column(String(50), nullable=True) habla = Column(Boolean, default=True) lee = Column(Boolean, default=True) escribe = Column(Boolean, default=True) aprendio = Column(Boolean, default=True) enabled = Column(Boolean, default=True) persona = relationship("Persona")
class Role(Native): __mapper_args__ = {"concrete": True} __tablename__ = "Roles" id = Column(Integer, primary_key = True) parent_id = Column(Integer, ForeignKey("Roles.id")) name = Column(String(255), unique = True) description = Column(String(255)) parent = recursion("parent_id") # ---------------------------------------------------------------------------- # def __init__(self, parent_id = 0, name = None, description = None): self.parent_id = parent_id self.name = name self.description = description
class Item(Base): __tablename__ = "item" id = Column(Integer, index=True, autoincrement=True, primary_key=True) image = Column(Text) name = Column(Text, nullable=False) item_code = Column(Text) ean_code = Column(Text) unit_price_in_bulk = Column(Integer) bulk_units = Column(Integer) unit_price = Column(Integer) retail_price = Column(Integer) in_stock = Column(Boolean, default=True) stock_quantity = Column(Integer, default=1) brand_id = Column(Integer, ForeignKey("brand.id"), nullable=False) brand = relationship("Brand")
class Manzano(Serializable, Base): way = {'urbanizacion': {}} __tablename__ = 'manzano' id = Column(Integer, primary_key=True) numero = Column(String(50), nullable=False) calle1 = Column(String(100), nullable=False) calle2 = Column(String(100), nullable=False) fkurbanizacion = Column(Integer, ForeignKey('urbanizacion.id'), nullable=True) enabled = Column(Boolean, default=True) urbanizacion = relationship('Urbanizacion')
class Probe(BaseModel): __tablename__ = "solvent_probes" id = Column(String, primary_key=True) solvent = Column(String, ForeignKey("solvents.id", onupdate="CASCADE", ondelete="CASCADE"), primary_key=True, nullable=False) mask = Column(String) types = relationship("ProbeType", secondary=PROBES_TO_TYPES_ASSOCIATION_TABLE) def __repr__(self) -> str: return f"[{self.id}]: {','.join([t.id for t in self.types])}"
class UserLoginToken(base.Base): __tablename__ = "users_login_tokens" id = Column(Integer, primary_key=True) user_id = Column(Integer, ForeignKey("users.id"), nullable=False) # core data login_token = Column(String, unique=True, default=lambda: str(hash(uuid4()))) is_active = Column(Boolean, nullable=False, default=True) # relationship # metadata created_at = Column( DateTime(timezone=True), default=lambda: datetime.now(tz=timezone.utc) )
class RetreatEmployeeLocationItem(base.Base): __tablename__ = "retreats_employees_locations_items" id = Column(Integer, primary_key=True) submission_id = Column( Integer, ForeignKey("retreats_employees_locations_submissions.id"), nullable=False, ) employee_count = Column(Integer, nullable=False) google_place_id = Column(String, nullable=False) main_text = Column(String, nullable=False) secondary_text = Column(String, nullable=False)
class OAISync(db.Model): __tablename__ = "oarepo_oai_sync" id = db.Column(db.Integer, primary_key=True) provider_id = db.Column(db.Integer, ForeignKey('oarepo_oai_provider.id')) sync_start = db.Column(db.TIMESTAMP) sync_end = db.Column(db.TIMESTAMP) status = db.Column(db.String(32)) logs = db.Column(db.Text()) # number of created, modified and deleted records for statistics rec_created = db.Column(db.Integer) rec_modified = db.Column(db.Integer) rec_deleted = db.Column(db.Integer) provider = relationship("OAIProvider", backref=backref("synchronizations")) traceback = relationship("OAIRecordExc", backref=backref("synchronizations"))
def connection(sync_engine): with sync_engine.connect() as conn: metadata = MetaData() Table("table", metadata, Column("column1", Integer, primary_key=True)) Table("table2", metadata, Column("fk_column", ForeignKey("table.column1"))) if conn.dialect.name != "sqlite": conn.execute(CreateSchema("altschema")) Table("table3", metadata, Column("fk_column", Integer), schema="altschema") metadata.create_all(conn) yield conn if conn.dialect.name != "sqlite": metadata.drop_all(conn) conn.execute(DropSchema("altschema"))
class VmCorTaxonPhenology(DB.Model): __tablename__ = "vm_cor_taxon_phenology" __table_args__ = {"schema": "gn_profiles"} cd_ref = DB.Column(DB.Integer, primary_key=True) doy_min = DB.Column(DB.Integer, primary_key=True) doy_max = DB.Column(DB.Integer, primary_key=True) id_nomenclature_life_stage = DB.Column( DB.Integer, ForeignKey("ref_nomenclatures.t_nomenclatures.id_nomenclature"), primary_key=True, ) extreme_altitude_min = DB.Column(DB.Integer) calculated_altitude_min = DB.Column(DB.Integer) extreme_altitude_max = DB.Column(DB.Integer) calculated_altitude_max = DB.Column(DB.Integer) nomenclature_life_stage = DB.relationship("TNomenclatures")
class Modulo(Serializable, Base): way = {'roles': {}} __tablename__ = 'cb_usuarios_modulo' id = Column('cb_modulo_id', Integer, primary_key=True) route = Column('cb_modulo_route', String(100)) title = Column('cb_modulo_title', String(100), nullable=False) name = Column('cb_modulo_name', String(100), nullable=False, unique=True) icon = Column('cb_modulo_icon', String(50), nullable=False, default='home') menu = Column('cb_modulo_menu', Boolean, nullable=False, default=True) fkmodulo = Column('cb_modulo_fkmodulo', Integer, ForeignKey('cb_usuarios_modulo.cb_modulo_id')) roles = relationship('Rol', secondary=Acceso) children = relationship('Modulo')
class AyudaVentas(Serializable, Base): way = {} __tablename__ = 'cb_ayudaventas' id = Column(Integer, primary_key=True) nombre = Column(String(255), nullable=True) codigo = Column(Integer, unique=True, nullable=False) codvta = Column(String(10), nullable=False) precio = Column(Float, nullable=False) prepro = Column(Float, nullable=False) retail = Column(Integer, nullable=False) bonifi = Column(Float, nullable=False) gestion = Column(Integer, nullable=True) catalogo = Column(Integer, ForeignKey("cb_catalogo.id")) foto = Column(Text, nullable=True, default=" ") enabled = Column(Boolean, default=True)
class ReportSelinuxMode(GenericTable): __tablename__ = "reportselinuxmodes" report_id = Column(Integer, ForeignKey("{0}.id".format(Report.__tablename__), ondelete="CASCADE"), primary_key=True) mode = Column(Enum("DISABLED", "PERMISSIVE", "ENFORCING", name="reportselinuxmode_mode"), primary_key=True) count = Column(Integer, nullable=False) report = relationship(Report, backref="selinux_modes") def __str__(self) -> str: return self.mode.lower().capitalize()
class ReportReason(GenericTable): __tablename__ = "reportreasons" report_id = Column(Integer, ForeignKey("{0}.id".format(Report.__tablename__), ondelete="CASCADE"), primary_key=True) reason = Column(String(512), nullable=False, primary_key=True) count = Column(Integer, nullable=False) report = relationship(Report, backref="reasons") def __str__(self) -> str: crash_fn = 'unknown function' if self.report.backtraces: crash_fn = self.report.backtraces[0].crash_function return format_reason(self.report.type, self.reason, crash_fn)
class ReportBtThread(GenericTable): __tablename__ = "reportbtthreads" id = Column(Integer, primary_key=True) backtrace_id = Column(Integer, ForeignKey("{0}.id".format( ReportBacktrace.__tablename__), ondelete="CASCADE"), nullable=False, index=True) number = Column(Integer, nullable=True) crashthread = Column(Boolean, nullable=False) backtrace = relationship(ReportBacktrace, backref=backref("threads", order_by="ReportBtThread.number", passive_deletes=True))
class Marcaciones(Serializable, Base): way = {'dispositivo': {}} __tablename__ = 'cb_dispositivos_marcaciones' __table_args__ = ({"schema": "ASISTENCIA"}) id = Column(Integer, Sequence('id'), primary_key=True) codigo = Column(Integer, nullable=False) time = Column(DateTime) fkdispositivo = Column( Integer, ForeignKey('ASISTENCIA.cb_dispositivos_lectores.id'), nullable=True) enabled = Column(Boolean, default=True) dispositivo = relationship('Lectores')
class Blog(Model): __mapper_args__ = {"concrete": True} __tablename__ = "Blog" id = Column(Integer, primary_key=True) createdOn = Column(DateTime) changedOn = Column(DateTime) author_id = Column(Integer, ForeignKey("Users.id")) author = relationship("Editor") title = Column(String(255)) content = Column(Text) # ---------------------------------------------------------------------------- # def __init__(self, author_id=0, title=None, content=None): self.author_id = author_id self.title = title self.content = content
class Bitacora(Serializable, Base): way = {'usuario': {}} __tablename__ = 'cb_operaciones_bitacora' __table_args__ = ({"schema": "ASISTENCIA"}) id = Column(BigInteger, Sequence('id'), primary_key=True) fkusuario = Column(Integer, ForeignKey('ASISTENCIA.cb_usuarios_usuario.id'), nullable=True) ip = Column(String(100), nullable=True) accion = Column(String(200), nullable=True) fecha = Column(DateTime, nullable=False, default=fecha_zona) tabla = Column(String(200), nullable=True) identificador = Column(Integer, nullable=True) usuario = relationship('Usuario')