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