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