class Subastas_Productos(db.Model):
__tablename__ = "SUBASTAS_PRODUCTOS"
idSubastasProductos = db.Column(db.Integer, primary_key=True)
idSubasta = db.Column(db.Integer,
db.ForeignKey(Subastas.idSubasta),
nullable=False)
idProducto = db.Column(db.Integer,
db.ForeignKey(Productos.idProducto),
nullable=False)
Cantidad = db.Column(db.Float)
def __init__(self, idSubasta, idProducto, Cantidad):
self.idSubasta = idSubasta
self.idProducto = idProducto
self.Cantidad = Cantidad
class TestRun(db.Model):
__tablename__ = 'testruns'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255), index=True)
timestamp = db.Column(db.DateTime, default=datetime.datetime.utcnow())
waved = db.Column(db.Boolean)
operatingsystem_id = db.Column(db.Integer,
db.ForeignKey('operatingsystems.id'))
operatingsystem = db.relationship(
'OperatingSystem',
backref=db.backref('testruns', lazy='dynamic'),
)
project_id = db.Column(db.Integer, db.ForeignKey('projects.id'))
project = db.relationship(
'Project',
backref=db.backref('testruns', lazy='dynamic'),
)
release_id = db.Column(db.Integer, db.ForeignKey('releases.id'))
release = db.relationship(
'Release',
backref=db.backref('testruns', lazy='dynamic'),
)
passed = db.Column(db.Integer)
failed = db.Column(db.Integer)
skipped = db.Column(db.Integer)
error = db.Column(db.Integer)
total = db.Column(db.Integer)
total_executed = db.Column(db.Integer)
percent_passed = db.Column(db.Float)
percent_failed = db.Column(db.Float)
percent_executed = db.Column(db.Float)
percent_not_executed = db.Column(db.Float)
notes = db.Column(db.Text)
def update_stats(self):
self.total = sum([self.passed, self.failed, self.skipped, self.error])
self.total_executed = sum([self.passed, self.failed])
self.percent_passed = ((self.passed / float(self.total_executed)) *
100 if self.total_executed > 0 else 0)
self.percent_failed = ((self.failed / float(self.total_executed)) *
100 if self.total_executed > 0 else 0)
self.percent_executed = ((self.total_executed / float(self.total)) *
100 if self.total > 0 else 0)
self.percent_not_executed = ((self.skipped / float(self.total)) *
100 if self.total > 0 else 0)
class Coupon(db.Model, Base):
"""Model for Udemy course coupon db table."""
__tablename__ = "coupons"
id = db.Column(db.Integer, primary_key=True)
courseId = db.Column(db.Integer, db.ForeignKey("courses.id"))
code = db.Column(db.String, nullable=False)
link = db.Column(db.String, nullable=False)
price = db.Column(db.Numeric(4, 2), nullable=False)
utcExpirationISO = db.Column(db.DateTime(timezone=True), nullable=False)
def __init__(
self,
code: str,
link: str,
utcExpirationISO: str,
price: float,
courseId: int = None,
update_db: bool = True,
):
"""Create record and add to db, translating the expiration date to utc."""
self.courseId = courseId
self.code = code
self.utcExpirationISO = dateutil.parser.parse(utcExpirationISO)
self.price = price
self.link = link
if update_db:
self.update_db()
def to_dict(self):
"""Return the called upon resource to dictionary format."""
return {
"id": self.id,
"courseId": self.courseId,
"code": self.code,
"link": self.link,
"price": float(self.price),
"utcExpirationISO": datetime.isoformat(self.utcExpirationISO),
}
def is_valid(self) -> bool:
"""Return boolean representing whether the coupon is valid."""
return self.utcExpirationISO > datetime.now(utc)
def update(self, updated_data):
"""Update with new data."""
for key, value in updated_data.items():
if key == "id":
continue
setattr(self, key, value)
def __repr__(self):
"""Return a pretty print version of the retrieved resource."""
return f""" < CourseCoupon(id={self.id},
class Productos_Supermercados(db.Model, BaseModelMixin):
__tablename__ = "PRODUCTOS_SUPERMERCADOS"
idProductoSupermercado = db.Column(db.Integer, primary_key=True)
idSupermercado = db.Column(db.Integer, db.ForeignKey(Supermercados.idSupermercado), nullable=False)
idProducto = db.Column(db.Integer, db.ForeignKey(Productos.idProducto), nullable=False)
fechaProducto = db.Column(db.Date)
precioRegular = db.Column(db.Float)
precioOnline = db.Column(db.Float)
precioTarjeta = db.Column(db.Float)
nombreTarjeta = db.Column(db.String)
@classmethod
def get_detalle_subasta1(self, idSubasta):
filtro = db.session.query(func.min(Productos_Supermercados.precioOnline).label("precioMin"), Productos.idProducto). \
join(Productos, Productos.idProducto == Productos_Supermercados.idProducto).\
join(Subastas_Productos, Subastas_Productos.idProducto == Productos.idProducto).\
filter(Subastas_Productos.idSubasta == idSubasta).group_by(Productos.idProducto).all()
filtro1 = db.session.query(Subastas_Productos, Productos). \
join(Productos, Productos.idProducto == Subastas_Productos.idProducto). \
filter(Subastas_Productos.idSubasta == idSubasta).all()
arr = []
for data in filtro:
dicc = {}
precioMin = data[0]
idProducto = data[1]
for subasta_productos in filtro1:
if idProducto == subasta_productos[0].idProducto:
cantidad = subasta_productos[0].Cantidad
nombreProducto = subasta_productos[1].nombreProducto
dicc = {
"Subastas_Productos.Cantidad": cantidad,
"Productos_Supermercados.idSupermercado": 3,
"Subastas_Productos.idSubasta": idSubasta,
"Productos_Supermercados.precioOnline": precioMin,
"Productos.nombreProducto": nombreProducto,
"Productos.idProducto": idProducto
}
arr.append(dicc)
return arr
class UserPuzzleRatings(db.Model):
"""Class to represent the relation between user, puzzle, and the rating
the user gave the puzzle after completing it.
"""
__tablename__ = "puzzle_ratings"
__table_args__ = {'sqlite_autoincrement' : True}
cid = db.Column(db.Integer, db.ForeignKey("crosswords.cid"), primary_key=True)
uid = db.Column(db.Integer, db.ForeignKey("user.uid"), primary_key=True)
# Rating should be between 1 and 5
rating = db.Column(db.Integer, unique=False)
def __init__(self, cid, uid, rating):
self.cid = cid
self.uid = uid
self.rating = rating
class FrameworkModel(db.Model):
__table_args__ = {"schema": "ds"}
__tablename__ = 'framework_models'
gid = db.Column(db.Integer, primary_key=True)
fw_id = db.Column(db.Integer, db.ForeignKey('ds.framework.fw_id')) # 框架ID
model_id = db.Column(db.Integer,
db.ForeignKey('ds.model.model_id')) # 模块ID
def __repr__(self):
return '<FrameworkModels %r:%r>' % (self.fw_id, self.model_id)
def to_dict(self):
d = {}
for column in self.__table__.columns:
d[column.name] = getattr(self, column.name)
return d
class Book(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(128), index=True)
author = db.Column(db.String(64))
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
def __repr__(self):
return f'<Book "{self.title}" (by {self.author})>'
class SubuserModel(db.Model):
__tablename__ = 'disciplina_usuario'
"""
Modelo de controle das disciplinas associadas ao usuário apos a falta ser computada.
"""
id = db.Column(db.Integer, primary_key=True)
is_active = db.Column(db.Boolean, default=True)
sub_id = db.Column(db.Integer,
db.ForeignKey('disciplina.id', ondelete="CASCADE"))
user_id = db.Column(db.Integer, db.ForeignKey('usuario.id'))
absences = db.relationship('AbsenceModel',
backref='user_absence',
passive_deletes=True,
order_by='AbsenceModel.date')
__table_args__ = (db.Index('only_subuser', sub_id, user_id, unique=True), )
class Observationperiod(Base):
start_time = db.Column(db.DateTime, nullable=False)
end_time = db.Column(db.DateTime, nullable=False)
type_id = db.Column(db.Integer, db.ForeignKey('type.id'), nullable=False)
location_id = db.Column(db.Integer, db.ForeignKey('location.id'), nullable=False)
day_id = db.Column(db.Integer, db.ForeignKey('day.id'), nullable=False)
Shorthand = db.relationship("Shorthand", backref="observationperiod", lazy=True)
def __init__ (self, start_time, end_time, type_id, location_id, day_id):
self.start_time = start_time
self.end_time = end_time
self.type_id = type_id
self.location_id = location_id
self.day_id = day_id
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String)
meme_id = db.Column(db.Integer, db.ForeignKey('memes.id'))
def __repr__(self):
return f'User {self.id} {self.name} {self.meme_id}'
class TodoModel(db.Model):
__tablename__ = 'todo'
id = db.Column(db.Integer(), primary_key=True)
text = db.Column(db.Unicode())
completed = db.Column(db.Boolean(), default=False)
user_id = db.Column(None, db.ForeignKey('user.id'))
class Subastas(db.Model, BaseModelMixin):
__tablename__ = "SUBASTAS"
idSubasta = db.Column(db.Integer, primary_key=True)
idUsuario = db.Column(db.Integer,
db.ForeignKey(Usuarios.idUsuario),
nullable=False)
idEstado = db.Column(db.Integer,
db.ForeignKey(Estado.idEstado),
nullable=False)
tiempoInicial = db.Column(db.Date)
nombreSubasta = db.Column(db.String)
precioIdeal = db.Column(db.Float)
idDireccion = db.Column(db.Integer)
fechaSubasta = db.Column(db.DateTime)
subastas_productos = db.relationship('Subastas_Productos',
backref='Subastas',
lazy=True)
@classmethod
def get_joins_filter_ubastas_usuarios(self, idUsuario, idEstado):
filtro = db.session.query(Subastas, Subastas_Productos, Productos). \
outerjoin(Subastas_Productos, Subastas.idSubasta == Subastas_Productos.idSubasta). \
outerjoin(Productos, Subastas_Productos.idProducto == Productos.idProducto). \
filter(Subastas.idUsuario == idUsuario). \
filter(Subastas.idEstado == idEstado).all()
return filtro
@classmethod
def find_by_id(cls, id):
print("entro a find_by_id")
return cls.query.get(id)
def save_to_db(self):
db.session.add(self)
db.session.commit()
def __init__(self, idUsuario, idEstado, tiempoInicial, nombreSubasta,
precioIdeal, idDireccion, fechaSubasta):
self.idUsuario = idUsuario
self.idEstado = idEstado
self.tiempoInicial = tiempoInicial
self.nombreSubasta = nombreSubasta
self.precioIdeal = precioIdeal
self.idDireccion = idDireccion
self.fechaSubasta = fechaSubasta
class ShoppingListModel(db.Model):
__tablename__ = 'shopping_list'
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.Unicode())
description = db.Column(db.Unicode())
user_id = db.Column(None, db.ForeignKey('user.id'))
class UserAnswerModel(db.Model):
__tablename__ = 'user_answer'
id = db.Column(db.Integer, primary_key=True)
answer = db.Column(db.Integer)
text = db.Column(db.String(80))
created_at = db.Column(db.DateTime(timezone=True),
default=datetime.datetime.utcnow)
updated_at = db.Column(db.DateTime(timezone=True),
onupdate=datetime.datetime.utcnow)
deleted = db.Column(db.Boolean, default=False)
user_survey_id = db.Column(db.Integer,
db.ForeignKey('user_survey.id'),
nullable=False)
user_survey = db.relationship('UserSurveyModel')
question_id = db.Column(db.Integer,
db.ForeignKey('question.id'),
nullable=False)
question = db.relationship('QuestionModel')
answer_score_id = db.Column(db.Integer,
db.ForeignKey('answer_score.id'),
nullable=False)
answer_score = db.relationship('AnswerScoreModel')
def save_to_db(self) -> None:
db.session.add(self)
db.session.commit()
def delete_from_db(self) -> None:
db.session.delete(self)
db.session.commit()
@classmethod
def find_by_id(cls, _id):
return cls.query.filter_by(id=_id).first()
@classmethod
def find_by_answer(cls, answer):
return cls.query.filter_by(answer=answer).first()
@classmethod
def find_all(cls) -> List["UserAnswerModel"]:
return cls.query.all()
class Stock(db.Model):
"""
"""
id = db.Column(db.Integer, primary_key=True)
product_id = db.Column(db.Integer, db.ForeignKey('product.id'))
quantity = db.Column(db.Integer, nullable=False)
created_at = db.Column(db.DateTime, default=datetime.now())
updated_at = db.Column(db.DateTime, default=datetime.now())
class Product(db.Model):
__tablename__ = 'products'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80))
price = db.Column(db.Float(precision=2))
quantity = db.Column(db.Integer())
description = db.Column(db.String(200))
minutes_preparation = db.Column(db.Integer())
image_path = db.Column(db.String(80))
product_type_id = db.Column(db.Integer, db.ForeignKey('product_types.id'))
product_type = db.relationship('ProductType')
#orders = db.relationship('Order', lazy='dynamic')
def __init__(self, product_type_id, name, price, quantity, description, minutes_preparation,image_path):
self.name = name
self.price = price
self.quantity = quantity
self.description = description
self.minutes_preparation = minutes_preparation
self.image_path=image_path
self.product_type_id=product_type_id
@classmethod
def find_by_id(cls, _id):
return cls.query.filter_by(id=_id).first()
@classmethod
def find_by_name(cls, name):
return cls.query.filter_by(name=name).first()
def save_to_db(self):
db.session.add(self)
db.session.commit()
def delete_from_db(self):
db.session.delete(self)
db.session.commit()
@classmethod
def init_data(cls):
cls(1, "Hamburger", 6, 10, "A 150Gr grilled meat hamburger. Comes with french fries and salad.", 15, "/images/hamburger.jpg").save_to_db()
cls(1, "Chicken", 7, 10, "A 300Gr breaded chicken. comes with potatoes and salad", 15, "/images/chicken.jpg").save_to_db()
cls(1, "Paella", 9, 10, "Perfect for the seafood lovers, it comes with oysters and mussels", 15, "/images/paella.jpg").save_to_db()
cls(1, "Ribs", 12, 10, "300Gr Ribs. Comes with french fries.", 15, "/images/ribs.jpg").save_to_db()
cls(1, "Salmon", 12, 10, "Chilean salmon. Comes with vegetables.", 15, "/images/salmon.jpg").save_to_db()
cls(1, "Wrap", 7, 10, "Wrap with chicken and salad.", 15, "/images/wrap.jpg").save_to_db()
cls(2, "Soda", 2, 7, "250cc soda. The soda comes with pieces of fruit.", 5, "/images/soda.jpg").save_to_db()
cls(2, "Juice", 3, 7, "330cc juice. Made of tropical fruits.", 9, "/images/juice.jpg").save_to_db()
cls(2, "Tee", 3, 7, "200cc Tee.", 12, "/images/tee.jpg").save_to_db()
cls(2, "Beer", 2, 7, "500cc Beer.", 3, "/images/beer.jpg").save_to_db()
cls(3, "Pancakes", 4, 7, "Baked pancakes with syrup or honey.", 12, "/images/pancakes.jpg").save_to_db()
cls(3, "Macaroons", 3, 7, "Try our special macaroon recipe.", 3, "/images/macaroons.jpg").save_to_db()
cls(3, "Forest fruit Cake", 3, 7, "This cake has a great variety of forest fruits, such as blackberries and raspberries.", 5, "/images/cake.jpg").save_to_db()
class User(UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(120), index=True, unique=True)
password_hash = db.Column(db.String(128))
#account_types = Personal, Professional, Business, Premium
account_type = db.Column(db.String(120), default='Business')
user_type = db.Column(db.String(120), default='Beta')
state = db.Column(db.String(120), default=fake.state_abbr())
country = db.Column(db.String(120),
default=fake.country_code(representation="alpha-2"))
set_path = db.Column(db.String(120), default='default')
company = db.Column(db.String(255), default=fake.company())
plan_id = db.Column(db.Integer, db.ForeignKey('plan.id'), default=1)
plan = db.relationship("Plan", backref="user", lazy="subquery")
def _set_default_plan(self):
return Plan.query.filter_by(name='free').first()
def __repr__(self):
return '<User {}>'.format(self.username)
def set_password(self, password):
self.password_hash = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password_hash, password)
def get_email_hash(self):
return hashlib.md5(self.email.encode()).hexdigest()
def get_ld_user(self):
app_version = current_app.config['VERSION']
milliseconds = int(round(time.time() * 1000))
user_key = self.get_email_hash()
user = {
'key': user_key,
'email': self.email,
"custom": {
'account_type': self.account_type,
'user_type': self.user_type,
'state': self.state,
'country': self.country,
'app_version': app_version,
'company': self.company or 'None',
'date': milliseconds,
'plan': self.plan.name
},
'privateAttributeNames': ['account_type', 'state'],
}
return user
def get_random_ld_user(self):
user = {'key': str(uuid.uuid1()), 'anonymous': True}
return user
class RolePermission(db.Model):
__table_args__ = {"schema": "public"}
__tablename__ = 'role_permissions'
gid = db.Column(db.Integer, primary_key=True)
role_id = db.Column(db.Integer,
db.ForeignKey('public.role.role_id')) # 角色id
perm_id = db.Column(db.Integer,
db.ForeignKey('public.permission.perm_id')) # 权限id
def __repr__(self):
return '<RolePermission %r:%r>' % (self.role_id, self.perm_id)
def to_dict(self):
d = {}
for column in self.__table__.columns:
d[column.name] = getattr(self, column.name)
return d
class Vote(db.Model):
__tablename__ = 'vote'
id = db.Column(db.Integer, primary_key= True)
vote = db.Column(db.Integer, default=0)
submitted = db.Column(db.DateTime, default = datetime.now)
option_id = db.Column(db.Integer, db.ForeignKey('options.id'))
def __repr__(self):
return f'{self.id}, {self.vote}, {self.submitted}, {self.option_id}'
class Pujas(db.Model, BaseModelMixin):
__tablename__ = "PUJAS"
idPuja = db.Column(db.Integer, primary_key=True)
idSubasta = db.Column(db.Integer,
db.ForeignKey(Subastas.idSubasta),
nullable=False)
idUsuario = db.Column(db.Integer,
db.ForeignKey(Usuarios.idUsuario),
nullable=False)
precioPuja = db.Column(db.Float)
fechaPuja = db.Column(db.DateTime)
def __init__(self, idSubasta, idUsuario, precioPuja, fechaPuja):
self.idSubasta = idSubasta
self.idUsuario = idUsuario
self.precioPuja = precioPuja
self.fechaPuja = fechaPuja
class DSDrbfm(db.Model):
__table_args__ = {"schema": "ds"}
__tablename__ = 'ds_drbfm'
gid = db.Column(db.Integer, primary_key=True)
sec_id = db.Column(db.Integer, db.ForeignKey('ds.ds_section.sec_id'))
item_id = db.Column(db.Integer, db.ForeignKey('ds.ds_failure.item_id'))
scene_id = db.Column(db.Integer, db.ForeignKey('ds.ds_scene.scene_id'))
drbfm_content = db.Column(db.String(2048))
def __repr__(self):
return '<CheckItem %r>' % self.content
def to_dict(self):
d = {}
for column in self.__table__.columns:
d[column.name] = getattr(self, column.name)
return d
class Project(db.Model):
__tablename__ = 'project'
id = db.Column(db.Integer, primary_key=True)
owner = db.Column(db.Integer, db.ForeignKey('user.id'))
name = db.Column(db.String(60))
link = db.Column(db.String(255))
def __repr__(self):
return '<Project %r, name: %r, owner: %r>' % (self.id, self.name, self.owner)
class UserModel(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(255))
password = db.Column(db.String(60))
right_id = db.Column(db.Integer, db.ForeignKey('rights.id'), default=1)
right = db.relationship('UserRightModel', back_populates="users")
username = db.Column(db.String(100), default='')
position = db.Column(db.String(100), default='')
hide = db.Column(db.Boolean(), default=0)
@validates('email')
def validate_email(self, key, email):
assert '@' in email
return email
def __init__(self, email, password):
self.email = email
self.password = password
def json(self):
right = UserRightModel.find_by_id(self.right_id)
return {
'id': self.id,
'email': self.email,
'right_id': self.right_id,
'right': self.right.json(),
'username': self.username,
'position': self.position,
'hide': self.hide
}
@classmethod
def find_by_email(cls, email):
return cls.query.filter_by(email=email).first()
@classmethod
def find_by_id(cls, _id):
return cls.query.filter_by(id=_id).first()
@classmethod
def find_all(cls):
return cls.query.all()
def save_to_db(self):
db.session.add(self)
db.session.commit()
def delete_from_db(self):
db.session.delete(self)
db.session.commit()
@classmethod
def create_random_password(cls):
return secrets.tocken_hex(8)
class TestCase(db.Model):
__tablename__ = 'testcases'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255), index=True, unique=True)
type_id = db.Column(db.Integer, db.ForeignKey('testtypes.id'))
type = db.relationship(
'TestType',
backref=db.backref('testcases', lazy='dynamic'),
)
category_id = db.Column(db.Integer, db.ForeignKey('categories.id'))
category = db.relationship(
'Category',
backref=db.backref('testcases', lazy='dynamic'),
)
def __repr__(self):
return '<Test Case {0}>'.format(self.name)
class ProjectTag(db.Model):
__table_args__ = {"schema": "ds"}
__tablename__ = 'project_tags'
gid = db.Column(db.Integer, primary_key=True)
proj_id = db.Column(db.Integer,
db.ForeignKey('ds.project.proj_id')) # 项目ID
tag_id = db.Column(db.Integer,
db.ForeignKey('public.doc_tag_category.tag_id')) # 模块ID
def __repr__(self):
return '<ProjectTag %r:%r>' % (self.proj_id, self.tag_id)
def to_dict(self):
d = {}
for column in self.__table__.columns:
d[column.name] = getattr(self, column.name)
return d
class ProductTransaction(db.Model):
__tablename__ = 'product_transaction'
id = db.Column(
db.Integer,
primary_key = True,
autoincrement = True
)
product_id = db.Column(
db.Integer,
db.ForeignKey('products.id'),
nullable = False
)
transaction_id = db.Column(
db.Integer,
db.ForeignKey('transactions.id'),
nullable = False
)
product_qty = db.Column(
db.Integer,
nullable = False
)
product = db.relationship(
'Product',
backref = 'product_assoc',
lazy = 'joined'
)
transaction = db.relationship(
'Transaction',
backref = 'transaction_assoc'
'lazy' = 'joined'
)
@event.listens_for(db.session, 'before_flush')
def reduceProductStock(*args):
sess = args[0]
for obj in sess.new:
if not isinstance(obj, ProductTransactions):
continue
product = Products.query.filter_by(id = obj.product_id).first()
product.stock_qty = product.stock_qty - obj.product_qty
db.session.add(product)
class Comment(db.Model):
id = db.Column(db.Integer, primary_key=True)
text = db.Column(db.Text, nullable=True)
published = db.Column(db.DateTime, nullable=False, default=datetime.now())
# after relationship will need to make migration db
# export (set) FLASK_APP = app && flask db migrate && flask db upgrade
news_id = db.Column(db.Integer,
db.ForeignKey("news.id", ondelete="CASCADE"),
index=True)
user_id = db.Column(db.Integer,
db.ForeignKey("user.id", ondelete="CASCADE"),
index=True)
news = relationship("News", backref="comments")
user = relationship("User", backref="comments")
def __repr__(self):
return f"<Comment {self.id}>"
class Sub_Categorias(db.Model, BaseModelMixin):
__tablename__ = "SUB_CATEGORIAS"
idSubCategorias = db.Column(db.Integer, primary_key=True)
nombreSubCategoria = db.Column(db.String)
idCategoria = db.Column(db.Integer,
db.ForeignKey(Categorias.idCategoria),
nullable=False)
categoria = db.relationship('Tipos_Productos',
backref='Sub_Categorias',
lazy=True)
class Tipos_Productos(db.Model, BaseModelMixin):
__tablename__ = "TIPOS_PRODUCTOS"
idTipoProducto = db.Column(db.Integer, primary_key=True)
nombreProducto = db.Column(db.String)
idSubCategorias = db.Column(db.Integer,
db.ForeignKey(Sub_Categorias.idSubCategorias),
nullable=False)
productos = db.relationship('Productos',
backref='Tipos_Productos',
lazy=True)
class CheatSheetTag(db.Model, Base):
"""Model for association between cheat sheets and tags."""
__tablename__ = "cheat_sheet_tags"
id = db.Column(db.Integer, primary_key=True)
cheat_sheet_id = db.Column(db.Integer, db.ForeignKey("cheat_sheets.id"))
tag_id = db.Column(db.Integer, db.ForeignKey("tags.id"))
def __init__(
self,
cheat_sheet_id: int,
tag_id: int,
):
"""Add record to db."""
self.cheat_sheet_id = cheat_sheet_id
self.tag_id = tag_id
self.update_db()
