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