class HotelModel(db.Model): __tablename__ = 'hotels' hotel_id = db.Column(db.String, primary_key=True) name = db.Column(db.String(80)) stars = db.Column(db.Float(precision=1)) price = db.Column(db.Float(precision=2)) city = db.Column(db.String(40)) def __init__(self, hotel_id, name, stars, price, city): self.hotel_id = hotel_id self.name = name self.stars = stars self.price = price self.city = city def json(self): return { 'hotel_id': self.hotel_id, 'name': self.name, 'stars': self.stars, 'price': self.price, 'city': self.city } @classmethod def find_hotel(cls, hotel_id): hotel = cls.query.filter_by(hotel_id=hotel_id).first() if hotel_id: return hotel return None def save_hotel(self): db.session.add(self) db.session.commit()
class ContactModel(db.Model): __tablename__ = 'contacts' contact_id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String, nullable=False) phone = db.Column(db.Integer, unique=True, nullable=False) def __init__(self, name, phone): self.name = name self.phone = phone # Função para retornar o objeto em json def json(self): return { 'contact_id': self.contact_id, 'name': self.name, 'phone': self.phone } # classe método para procurar numero ou id @classmethod def find_contact_or_number(cls, find_dict): # se algum item for encontrado dentro do item 'phone' if find_dict['phone']: # verifica se o número ja existe, buscando apenas 1 resultado find_phone = cls.query.filter_by(phone=find_dict['phone']).first() # se existir retorna o mesmo encontrado if find_phone: return find_phone # mesma função decima if find_dict['contact_id']: find_id = cls.query.filter_by( contact_id=find_dict['contact_id']).first() if find_id: return find_id # se nada for encontrado return False # Salvar contato def save_contact(self): # Pega o objeto e salva no banco db.session.add(self) # realiza o commit para salvar as alterações db.session.commit() # Deletar contato def delete_contact(self): # Pega o objeto para deletar no banco db.session.delete(self) # realiza o commit para salvar as alterações db.session.commit() # Atualiza contato def update_contact(self, name, phone): # Incrementa os novos dados nas variaveis obj self.name = name self.phone = phone
class MenuModel(db.Model): __tablename__ = 'menu' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(64), nullable=False) price = db.Column(db.String(15), nullable=False) description = db.Column(db.String(256), nullable=False) menu = db.relationship(RecipeModel, backref=db.backref('menu', lazy=True)) def __init__(self, name, price, description): self.name = name self.price = price self.description = description def json(self): return { 'id': self.id, 'name': self.name, 'price': str(self.price), 'description': self.description, 'menu': [self.format_recipe(recipe.id, recipe.name, recipe.quantity) for recipe in self.menu] } def format_recipe(self, id, name, quantity): return { "id": id, "name": name, "quantity": quantity }
class RecipeModel(db.Model): id = db.Column(db.Integer, primary_key=True) menu_id = db.Column(db.Integer, db.ForeignKey('menu.id'), nullable=False) name = db.Column(db.String(16), nullable=False) quantity = db.Column(db.Integer, nullable=False) def __init__(self, menu_id, name, quantity): self.menu_id = menu_id self.name = name self.quantity = quantity def json(self): return { 'id': self.id, 'name': self.name, 'price': str(self.price), 'description': self.description, 'menu': [ self.format_recipe(recipe.id, recipe.name, recipe.quantity) for recipe in self.menu ] } def format_recipe(self, id, name, quantity): return {"id": id, "name": name, "quantity": quantity}
class SiteModel(db.Model): __tablename__ = 'sites' site_id = db.Column(db.Integer, primary_key=True, autoincrement=True) name = db.Column(db.String(80)) url = db.Column(db.String(180)) hoteis = db.relationship('HotelModel') def __init__(self, name, url): self.name = name self.url = url def json(self): return { "site_id": self.site_id, "name": self.name, "url": self.url, "hoteis": [hotel.json() for hotel in self.hoteis] } @classmethod def find_site(cls, url): site = cls.query.filter_by(url=url).first() if site: return site return None def save_site(self): db.session.add(self) db.session.commit() def delete_site(self): db.session.delete(self) db.session.commit()
class MicroServiceModel(db.Model): __tablename__ = "micro_service" id = db.Column(db.Integer, autoincrement=True, primary_key=True) name = db.Column(db.String(255)) description = db.Column(db.String(255)) cloud_id = db.Column(db.Integer, db.ForeignKey("cloud.id")) cloud = db.relationship( "CloudModel", backref="micro_service", primaryjoin="CloudModel.id==MicroServiceModel.cloud_id", uselist=False, cascade="all") budgeting_id = db.Column(db.Integer, db.ForeignKey('budgeting.id'), nullable=False) def __init__(self, name, description, cloud: CloudModel): self.name = name self.description = description self.cloud = cloud def json(self): return { "id": self.id, "name": self.name, "description": self.description, "cloud": self.cloud.json() }
class CloudModel(db.Model): __tablename__ = "cloud" id = db.Column(db.Integer, autoincrement=True, primary_key=True) cloudProviderEnum = db.Column(db.String(30)) region = db.Column(db.String(255)) zone = db.Column(db.String(255)) amount = db.Column(db.Float(precision=2)) services = db.relationship("ServiceModel", cascade="all") def __init__(self, cloudProviderEnum, region, zone, amount, services: List[ServiceModel]): self.cloudProviderEnum = cloudProviderEnum self.region = region self.zone = zone self.amount = amount self.services = services def json(self): return { "id": self.id, "cloudProviderEnum": self.cloudProviderEnum, "region": self.region, "zone": self.zone, "amount": self.amount, "services": [service.json() for service in self.services] }
class ProdutoPedidoModel(db.Model): __tablename__ = 'produto_pedido' cod_nota = db.Column(db.Integer, primary_key=True) qtd_produto = db.Column(db.Integer, nullable=False) valor_parcial = db.Column(db.Float, nullable=False) cod_pedido = db.Column(db.Integer, db.ForeignKey('pedido.cod_pedido')) id_produto = db.Column(db.Integer, db.ForeignKey('produto.id_produto')) def __init__(self, qtd_produto, valor_parcial, cod_pedido, id_produto): self.qtd_produto = qtd_produto self.valor_parcial = valor_parcial self.cod_pedido = cod_pedido self.id_produto = id_produto def json(self): return { 'cod_nota': self.cod_nota, 'qtd_produto': self.qtd_produto, 'valor_parcial': self.valor_parcial, 'cod_pedido': self.cod_pedido, 'id_produto': self.id_produto } @classmethod def find_produtoPedido(cls, cod_nota): pp = cls.query.filter_by(cod_nota=cod_nota).first() if pp: return pp return None @classmethod def find_produto(cls, id_produto): pp = cls.query.filter_by(id_produto=id_produto).first() if pp: return pp return None @classmethod def find_pedido(cls, cod_pedido): pp = cls.query.filter_by(cod_pedido=cod_pedido).first() if pp: return pp return None def save_produtoPedido(self): db.session.add(self) db.session.commit() def update_produtoPedido(self, qtd_produto, valor_parcial, cod_pedido, id_produto): self.qtd_produto = qtd_produto self.valor_parcial = valor_parcial self.cod_pedido = cod_pedido self.id_produto = id_produto def delete_produtoPedido(self): db.session.delete(self) db.session.commit()
class DeviceModel(db.Model): __tablename__ = 'device' id = db.Column(db.Integer, primary_key=True) mac = db.Column(db.String(30), unique=True) date_created = db.Column(db.DateTime(6), default=db.func.current_timestamp(), nullable=False) status = db.Column(db.String(3)) #tests = db.relationship('TestModel') #lista de objetos tests #monitoring = db.relationship('MonitoringModel') def __init__(self, mac, status): self.mac = mac self.date_created = str(date.today()) self.status = status def json(self): return { 'id': self.id, 'mac': self.mac, 'status': self.status #, #'tests':[test.json() for test in self.tests] } @classmethod def find_by_mac(cls, mac): device = cls.query.filter_by(mac=mac).first() if device: return device return None @classmethod def find_by_id(cls, id): device = cls.query.filter_by(id=id).first() if device: return device return None @classmethod def find_device_online(cls, status='ON'): device = cls.query.filter_by(status=status).all() if device: return device return None def save(self): db.session.add(self) db.session.commit() def update(self, status): self.status = status def delete(self): [test.delete() for test in self.tests] db.session.delete(self) db.session.commit()
class FornecedorModel(db.Model): __tablename__ = 'fornecedor' cod_fornecedor = db.Column(db.Integer, primary_key=True) cnpj_cpf = db.Column(db.String(18), unique=True, nullable=False) nome_fantasia = db.Column(db.String(150), nullable=False) razao_social = db.Column(db.String(150), nullable=False) ativo = db.Column(db.String(3), nullable=False) contato = db.relationship("ContatoModel") def __init__(self, cnpj_cpf, nome_fantasia, razao_social, ativo): self.cnpj_cpf = cnpj_cpf self.nome_fantasia = nome_fantasia self.razao_social = razao_social self.ativo = ativo def json(self): return { 'cod_fornecedor': self.cod_fornecedor, 'cnpj_cpf': self.cnpj_cpf, 'nome_fantasia': self.nome_fantasia, 'razao_social': self.razao_social, 'ativo': self.ativo, 'contatos': [contato.json() for contato in self.contato] } @classmethod def find_fornecedor(cls, cod_fornecedor): fornecedor = cls.query.filter_by(cod_fornecedor=cod_fornecedor).first() if fornecedor: return fornecedor return None @classmethod def find_fornecedor_cnpj_cpf(cls, cnpj_cpf): fornecedor = cls.query.filter_by(cnpj_cpf=cnpj_cpf).first() if fornecedor: return fornecedor return None def save_fornecedor(self): db.session.add(self) db.session.commit() def update_fornecedor(self, cod_fornecedor, cnpj_cpf, nome_fantasia, razao_social, ativo): self.cod_fornecedor = cod_fornecedor self.cnpj_cpf = cnpj_cpf self.nome_fantasia = nome_fantasia self.razao_social = razao_social self.ativo = ativo def delete_fornecedor(self): [contato.delete_contato() for contato in self.contato] db.session.delete(self) db.session.commit()
class MonitoringModel(db.Model): __tablename__ = 'monitoring' id = db.Column(db.Integer, primary_key=True) identifier = db.Column(db.String(60), unique=True) date_created=db.Column(db.DateTime(6),default=db.func.current_timestamp(),nullable=False) status = db.Column(db.Boolean) device_id = db.Column(db.String(30)) tests = db.relationship('TestModel') def __init__(self, identifier, status, device_id): self.identifier = identifier self.device_id = device_id self.date_created=date.today() self.status = status def json(self): return { 'identifier': self.identifier, 'status':self.status, #'tests':[test.json() for test in self.tests] } @classmethod def find_by_identifier(cls, identifier): print(identifier) monitoring = cls.query.filter_by(identifier=identifier).first() if monitoring: return monitoring return None @classmethod def find_by_id(cls, identifier): monitoring = cls.query.filter_by(identifier=identifier).first() if monitoring: return monitoring return None @classmethod def find__running(cls, status=True): monitoring = cls.query.order_by(desc(cls.id)).filter(and_(cls.status==1,cls.date_created==str(date.today()))).limit(250).all() return monitoring def save(self): db.session.add(self) db.session.commit() def update(self, status=False): self.status = status def delete(self): [test.delete() for test in self.tests] db.session.delete(self) db.session.commit()
class HotelModel(db.Model): #mapeando a classe para o SQLAlchemy(classe representa tabela) #nome da tabela __tablename__ = 'hoteis' #colunas hotel_id = db.Column(db.String, primary_key=True) nome = db.Column(db.String(80)) avaliacao = db.Column( db.Float(precision=1)) #precision determina quantas casas após o ponto diaria = db.Column(db.Float(precision=2)) cidade = db.Column(db.String(40)) #colunas --> atributos def __init__(self, hotel_id, nome, avaliacao, diaria, cidade): self.hotel_id = hotel_id self.nome = nome self.avaliacao = avaliacao self.diaria = diaria self.cidade = cidade def json(self): return { 'hotel_id': self.hotel_id, 'nome': self.nome, 'avaliacao': self.avaliacao, 'diaria': self.diaria, 'cidade': self.cidade } #semelhantemente ao @staticmethod, cria métodos que pertencem à classe e não ao objeto #mas com a diferença que, nesse caso, desejo referenciar a classe no método --> cls @classmethod def findHotel(cls, hotel_id): # SELECT * FROM hoteis WHERE hotel_id = $hotel_id ... hotel = cls.query.filter_by(hotel_id=hotel_id).first( ) #query.filter_by - recurso do sql alchemy. if hotel: return hotel return None def saveHotel(self): db.session.add(self) db.session.commit() def updateHotel(self, nome, avaliacao, diaria, cidade): self.nome = nome self.avaliacao = avaliacao self.diaria = diaria self.cidade = cidade def deleteHotel(self): db.session.delete(self) db.session.commit()
class OrderModel(db.Model): __tablename__ = 'orders' orderId = db.Column(db.Integer, primary_key=True) orderProduct = db.Column(db.String, nullable=False) orderAmount = db.Column(db.Integer, nullable=False) orderPrice = db.Column(db.Float(precision=2), default=0.0, nullable=False) orderEmail = db.Column(db.String, nullable=False) def __init__(self, orderProduct, orderAmount, orderPrice, orderEmail, orderPassword): self.orderProduct = orderProduct self.orderAmount = orderAmount self.orderPrice = orderPrice self.orderEmail = orderEmail def json(self): return { 'orderId': self.orderId, 'orderProduct': self.orderProduct, 'orderAmount': self.orderAmount, 'orderPrice': self.orderPrice, 'orderEmail': self.orderEmail } def newJson(self): return { 'productId': self.productId, 'productName': self.productName, 'category': self.category, 'amount': self.amount, 'description': self.description, 'price': self.price } @classmethod def find_order(cls, orderId): order = cls.query.filter_by(orderId=orderId).first() if order: return order return None def save_order(self): db.session.add(self) db.session.commit() def delete_order(self): db.session.delete(self) db.session.commit()
class FormaPagamentoModel(db.Model): __tablename__ = 'forma_pagamento' cod_formaPgameno = db.Column(db.Integer, primary_key=True) tipo_formaPagamento = db.Column(db.String(50), nullable=False) descricao_formaPagamento = db.Column(db.String(50), nullable=False) def __init__(self, tipo_formaPagamento, descricao_formaPagamento): self.tipo_formaPagamento = tipo_formaPagamento self.descricao_formaPagamento = descricao_formaPagamento def getTipoFormaPagamento(self): return self.tipo_formaPagamento def json(self): return { 'cod_formaPgameno': self.cod_formaPgameno, 'tipo_formaPagamento': self.tipo_formaPagamento, 'descricao_formaPagamento': self.descricao_formaPagamento } @classmethod def find_formaPagamento(cls, cod_formaPgameno): formaPgameno = cls.query.filter_by( cod_formaPgameno=cod_formaPgameno).first() if formaPgameno: return formaPgameno return None @classmethod def find_formaPagamento_tipo(cls, tipo_formaPagamento): formaPgameno = cls.query.filter_by( tipo_formaPagamento=tipo_formaPagamento).first() if formaPgameno: return tipo_formaPagamento return None def save_formaPagamento(self): db.session.add(self) db.session.commit() def update_formaPagamento(self, cod_formaPgameno, tipo_formaPagamento, descricao_formaPagamento): self.tipo_formaPagamento = tipo_formaPagamento self.descricao_formaPagamento = descricao_formaPagamento def delete_formaPagamento(self): db.session.delete(self) db.session.commit()
class FriendModel(db.Model): __tablename__ = 'friends' id = db.Column(db.Integer, primary_key=True) friend_name = db.Column(db.String(80)) entity_id = db.Column(db.Integer) def __init__(self, id, friend_name, entity_id): self.id = id self.friend_name = friend_name self.entity_id = entity_id def json(self): return { 'id': self.id, 'friend_name': self.friend_name, 'entity_id': self.entity_id } @classmethod def find_by_entity_id(cls, id): friends = cls.query.filter_by(entity_id=id) if friends: return friends return None @classmethod def find_by_id(cls, id): friend = cls.query.filter_by(id=id) if friend: return friend return None @classmethod def find(cls, friend_name): friend = cls.query.filter_by(friend_name=friend_name).first() if friend: return friend return None def save(self): db.session.add(self) db.session.commit() def delete(self): db.session.delete(self) db.session.commit()
class UserModel(db.Model): __tablename__ = 'users' user_id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(80)) login = db.Column(db.String(40)) password = db.Column(db.String(40)) def __init__(self, name, login, password): self.name = name self.login = login self.password = password def json(self): return { "user_id": self.user_id, "name": self.name, "login": self.login, } @classmethod def find_user(cls, user_id): user = cls.query.filter_by(user_id=user_id).first() if user: return user return None @classmethod def find_by_login(cls, login): user = cls.query.filter_by(login=login).first() if user: return user return None def save_user(self): db.session.add(self) db.session.commit() def update_user(self, nome, login, password): self.name = nome self.login = login self.password = password def delete_user(self): db.session.delete(self) db.session.commit()
class ServiceModel(db.Model): __tablename__ = "service" id = db.Column(db.Integer, autoincrement=True, primary_key=True) name = db.Column(db.String(255)) value = db.Column(db.Float(precision=2)) tag = db.Column(db.String(255)) instances = db.Column(db.String(4)) instanceType = db.Column(db.String(255)) cloud_id = db.Column(db.Integer, db.ForeignKey('cloud.id'), nullable=False) def __init__(self, name, value, tag, instances, instanceType): self.name = name self.value = value self.tag = tag self.instances = instances self.instanceType = instanceType def json(self): return { "id": self.id, "name": self.name, "value": self.value, "tag": self.tag, "instances": self.instances, "instanceType": self.instanceType }
class HotelModel(db.Model): __tablename__ = 'hoteis' hotel_id = db.Column(db.String, primary_key=True) nome = db.Column(db.String(80)) estrelas = db.Column(db.Float(precision=1)) diaria = db.Column(db.Float(precision=2)) cidade = db.Column(db.String(40)) def __init__(self, hotel_id, nome, estrelas, diaria, cidade): self.hotel_id = hotel_id self.nome = nome self.estrelas = estrelas self.diaria = diaria self.cidade = cidade def json(self): return { 'hotel_id': self.hotel_id, 'nome': self.nome, 'estrelas': self.estrelas, 'diaria': self.diaria, 'cidade': self.cidade } @classmethod def find_hotel(cls, hotel_id): hotel = cls.query.filter_by(hotel_id=hotel_id).first() if hotel: return hotel return None def save_hotel(self): db.session.add(self) db.session.commit() def update_hotel(self, nome, estrelas, diaria, cidade): self.nome = nome self.estrelas = estrelas self.diaria = diaria self.cidade = cidade def delete_hotel(self): db.session.delete(self) db.session.commit()
class UserModel(db.Model): #mapeando a classe para o SQLAlchemy(classe representa tabela) #nome da tabela __tablename__ = 'usuarios' #colunas user_id = db.Column(db.Integer, primary_key=True) login = db.Column(db.String(40)) senha = db.Column(db.String(40)) #colunas --> atributos def __init__(self, login, senha): self.login = login self.senha = senha def json(self): return {'user_id': self.user_id, 'login': self.login} #semelhantemente ao @staticmethod, cria métodos que pertencem à classe e não ao objeto #mas com a diferença que, nesse caso, desejo referenciar a classe no método --> cls @classmethod def findUser(cls, user_id): # SELECT * FROM usuarios WHERE user_id = $user_id ... user = cls.query.filter_by(user_id=user_id).first( ) #query.filter_by - recurso do sql alchemy. if user: return user return None @classmethod def find_by_login(cls, login): # SELECT * FROM usuarios WHERE user_id = $user_id ... user = cls.query.filter_by( login=login).first() #query.filter_by - recurso do sql alchemy. if user: return user return None def saveUser(self): db.session.add(self) db.session.commit() def deleteUser(self): db.session.delete(self) db.session.commit()
class BrandFoodChemicalModel(db.Model): __tablename__ = 'brand_food_chemical' id_brand = db.Column(db.Integer, db.ForeignKey('brand.id'), primary_key=True) id_food = db.Column(db.Integer, db.ForeignKey('food.id'), primary_key=True) id_chemical = db.Column(db.Integer, db.ForeignKey('chemical.id'), primary_key=True) chemicals = db.relationship('ChemicalModel', lazy='joined') def __init__(self, id_brand, id_food, id_chemical): self.id_brand = id_brand self.id_food = id_food self.id_chemical = id_chemical def json(self): return { 'brandId': self.id_brand, 'foodId': self.id_food, 'chemicalId': self.id_chemical } def chemical_name(self): return self.chemicals.json()['name'] @classmethod def find_by_brand_food(cls, brand_id, food_id): return cls.query.filter_by(id_brand=brand_id, id_food=food_id).order_by(unaccent(text("name"))) @classmethod def find_by_id(cls, brand_id, food_id, chemical_id): return cls.query.enable_eagerloads(False).filter_by(id_brand=brand_id, id_food=food_id, id_chemical=chemical_id).first() @classmethod def find_all(cls): return cls.query.enable_eagerloads(False).all() def save(self): db.session.add(self) def delete(self): db.session.delete(self) db.session.commit()
class EntityModel(db.Model): __tablename__ = 'entities_scores' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(80)) screenName = db.Column(db.String(140)) score = db.Column(db.Integer) def __init__(self, name, screenName, score): self.name = name self.screenName = screenName self.score = score def json(self): return { 'id': self.id, 'name': self.name, 'screenName': self.screenName, 'score': self.score } @classmethod def find_by_id(cls, id): entity = cls.query.filter_by(id=id).first() if entity: return entity return None @classmethod def find(cls, screenName): entity = cls.query.filter_by(screenName=screenName).first() if entity: return entity return None def save(self): db.session.add(self) db.session.commit() def delete(self): db.session.delete(self) db.session.commit()
class FoodModel(db.Model): __tablename__ = 'food' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(80), unique=True) def __init__(self, name): self.name = name def json(self): return { 'id': self.id, 'name': self.name, } @classmethod def find_food(cls, food_id): return cls.query.filter_by(id=food_id).first() @classmethod def find_by_name(cls, name): return db.session.query(FoodModel).filter( lower(unaccent(FoodModel.name)) == lower(unaccent(name))).first() @classmethod def find_foods(cls): return cls.query.order_by(unaccent(FoodModel.name)).all() def save_food(self): db.session.add(self) db.session.commit() def update_food(self, name): self.name = name db.session.add(self) db.session.commit() def delete_food(self): db.session.delete(self) db.session.commit()
class CategoriaModel(db.Model): __tablename__ = 'categoria' cod_categoria = db.Column(db.Integer, primary_key=True) nome_categoria = db.Column(db.String(50), nullable=False) def __init__(self, nome_categoria): self.nome_categoria = nome_categoria def json(self): return { 'cod_categoria': self.cod_categoria, 'nome_categoria': self.nome_categoria } @classmethod def find_categoria(cls, cod_categoria): categoria = cls.query.filter_by(cod_categoria=cod_categoria).first() if categoria: return categoria return None @classmethod def find_categoria_nome(cls, nome_categoria): categoria = cls.query.filter_by(nome_categoria=nome_categoria).first() if categoria: return categoria return None def save_categoria(self): db.session.add(self) db.session.commit() def update_categoria(self, cod_categoria, nome_categoria): self.cod_categoria = cod_categoria self.nome_categoria = nome_categoria def delete_categoria(self): db.session.delete(self) db.session.commit()
class CatModel(db.Model): __tablename__ = 'cats' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(40), nullable=False) age = db.Column(db.Integer, nullable=False) gender = db.Column(db.Enum("M", "F"), nullable=False) def __init__(self, name, age, gender): self.name = name self.age = age self.gender = gender def __repr__(self): return f"Cat(name = {name}, age = {age}, gender = {gender})" def json(self): data = { 'id': self.id, 'name': self.name, 'age': self.age, 'gender': self.gender } return data def save_cat(self): db.session.add(self) db.session.commit() def delete_cat(self): db.session.delete(self) db.session.commit() @classmethod def find_by_id(cls, id): cat = cls.query.filter_by(id=id).first() if cat: return cat return None
class ChemicalModel(db.Model): __tablename__ = 'chemical' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(80), unique=True) url = db.Column(db.String) def __init__(self, name, url): self.name = name self.url = url def json(self): return { 'id': self.id, 'name': self.name, 'url': self.url } @classmethod def find_chemical(cls, chemical_id): return cls.query.filter_by(id=chemical_id).first() @classmethod def find_chemicals(cls): return cls.query.filter(ChemicalModel.name != 'Nenhum').order_by(unaccent(ChemicalModel.name)).all() def save_chemical(self): db.session.add(self) def update_chemical(self, name): self.name = name db.session.add(self) db.session.commit() def delete_chemical(self): db.session.delete(self) db.session.commit()
class LogModel(db.Model): __tablename__ = 'log_error' id = db.Column(db.Integer, primary_key=True) device_id = db.Column(db.String(30)) date_created = db.Column(db.DateTime(6), default=db.func.current_timestamp(), nullable=False) level_error = db.Column(db.Integer) message = db.Column(db.String(100), nullable=False) def __init__(self, device_id, date_created, level_error, message): self.device_id = device_id self.date_created = date_created self.level_error = level_error self.message = message def json(self): return { 'device_id': self.device_id, 'date_created': (self.date_created.strftime('%d/%m/%Y')), 'level_error': self.level_error, 'message': self.message } @classmethod def get_log(cls, device_id): #log = cls.query.filter_by(device_id=device_id).all() #log2 = cls.query.order_by(desc(cls.level_error)).limit(2).all() log = cls.query.order_by(desc(cls.date_created)).filter( and_(cls.device_id == device_id, cls.date_created == str(date.today()))).limit(50).all() return log def save_log(self): db.session.add(self) db.session.commit()
class UserModel(db.Model): __tablename__ = "user" id = db.Column(db.Integer, autoincrement=True, primary_key=True) login = db.Column(db.String(40)) password = db.Column(db.String(40)) def __init__(self, login, password): self.login = login self.password = password def json(self): return {"id": self.id, "name": self.login} @classmethod def find_user(cls, id): user = cls.query.filter_by( id=id).first() # select * from user where id = $id if user: return user return None @classmethod def find_by_login(cls, login): user = cls.query.filter_by( login=login).first() # select * from user where login = $login if user: return user return None def save_user(self): db.session.add(self) db.session.commit() def delete_user(self): db.session.delete(self) db.session.commit()
class ProductModel(db.Model): __tablename__ = 'products' productId = db.Column(db.String(50), primary_key=True) productName = db.Column(db.String) category = db.Column(db.String(50)) amount = db.Column(db.Integer) description = db.Column(db.String) price = db.Column(db.Float(precision=2)) def __init__(self, productId, productName, category, amount, description, price): self.productId = productId self.productName = productName self.category = category self.amount = amount self.description = description self.price = price def json(self): return { 'productId': self.productId, 'productName': self.productName, 'category': self.category, 'amount': self.amount, 'description': self.description, 'price': self.price } @classmethod def find_product(cls, productId): product = cls.query.filter_by(productId=productId).first() if product: return product return None @classmethod def find_amount(cls, productId, orderAmount): product = cls.query.filter_by(product=product).first() if product: if orderAmount <= product.amount: return orderAmount return None def save_product(self): db.session.add(self) db.session.commit() def update_product(self, productName, category, amount, description, price): self.productName = productName self.category = category self.amount = amount self.description = description self.price = price def delete_product(self): db.session.delete(self) db.session.commit()
class HotelModel(db.Model): __tablename__ = 'hotel' hotel_id = db.Column(db.String, primary_key=True) nome = db.Column(db.String(80)) estrelas = db.Column(db.Float(precision=1)) diaria = db.Column(db.Float(precision=2)) cidade = db.Column(db.String(40)) def __init__(self, hotel_id, nome, estrelas, diaria, cidade): self.hotel_id = hotel_id self.nome = nome self.estrelas = hotel_id self.diaria = diaria self.cidade = cidade def json(self): return { 'hotel_id': self.hotel_id, 'nome': self.nome, 'estrelas': self.estrelas, 'diaria': self.diaria, 'cidade': self.cidade }
class UsuarioModel(db.Model): __tablename__ = 'usuarios' usuario_id = db.Column(db.Integer, primary_key=True) nome = db.Column(db.String(120)) email = db.Column(db.String(50)) def __init__(self, nome, email): self.nome = nome self.email = email def json(self): return { 'usuario_id': self.usuario_id, 'nome': self.nome, 'email':self.email } @classmethod def buscar_usuario(cls, usuario_id): usuario = cls.query.filter_by(usuario_id=usuario_id).first() if usuario: return usuario return None def salvar_usuario(self): db.session.add(self) db.session.commit() def atualizar_usuario(self, nome, email): self.nome = nome self.email = email def excluir_usuario(self): db.session.delete(self) db.session.commit()