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 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 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 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 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 ProdutoModel(db.Model):
__tablename__ = 'produto'
id_produto = db.Column(db.Integer, primary_key=True)
cod_produto = db.Column(db.String(50), nullable=False)
nome_produto = db.Column(db.String(150), nullable=False)
valor_produto = db.Column(db.Float(precision=2), nullable=False)
ativo = db.Column(db.String(3), nullable=False)
cod_categoria = db.Column(
db.Integer, db.ForeignKey('categoria.cod_categoria'))
cod_fornecedor = db.Column(
db.Integer, db.ForeignKey('fornecedor.cod_fornecedor'))
def __init__(self, cod_produto, nome_produto,
valor_produto, ativo, cod_categoria, cod_fornecedor):
self.cod_produto = cod_produto
self.nome_produto = nome_produto
self.valor_produto = valor_produto
self.ativo = ativo
self.cod_categoria = cod_categoria
self.cod_fornecedor = cod_fornecedor
def getCodProduto(self):
return self.cod_produto
def json(self):
return {
'id_produto': self.id_produto,
'cod_produto': self.cod_produto,
'nome_produto': self.nome_produto,
'valor_produto': self.valor_produto,
'ativo': self.ativo,
'cod_categoria': self.cod_categoria,
'cod_fornecedor': self.cod_fornecedor
}
@classmethod
def find_produto_by_cod(cls, cod_produto):
produto = cls.query.filter_by(cod_produto=cod_produto).first()
if produto:
return produto
return None
@classmethod
def find_produto(cls, id_produto):
produto = cls.query.filter_by(id_produto=id_produto).first()
if produto:
return produto
return None
@classmethod
def find_produto_categoria(cls, cod_fornecedor):
produto = cls.query.filter_by(cod_fornecedor=cod_fornecedor).first()
if produto:
return produto
return None
@classmethod
def find_produto_fornecedor(cls, cod_categoria):
produto = cls.query.filter_by(cod_categoria=cod_categoria).first()
if produto:
return produto
return None
def save_produto(self):
db.session.add(self)
db.session.commit()
def update_produto(self, id_produto, cod_produto, nome_produto,
valor_produto, ativo, cod_categoria, cod_fornecedor):
self.id_produto = id_produto
self.cod_produto = cod_produto
self.nome_produto = nome_produto
self.valor_produto = valor_produto
self.ativo = ativo
self.cod_categoria = cod_categoria
self.cod_fornecedor = cod_fornecedor
def delete_produto(self):
db.session.delete(self)
db.session.commit()
def __json_categoria(self, cod_categoria):
categoria = CategoriaModel.find_categoria(cod_categoria)
return categoria.json()
def __json_fornecedor(self, cod_fornecedor):
fornecedor = FornecedorModel.find_fornecedor(cod_fornecedor)
return fornecedor.json()
class ContatoModel(db.Model):
__tablename__ = 'contato'
cod_contato = db.Column(db.Integer, primary_key=True)
nome = db.Column(db.String(150), nullable=False)
logradouro = db.Column(db.String(150), nullable=False)
numero = db.Column(db.String(10), nullable=False)
bairro = db.Column(db.String(50), nullable=False)
cidade = db.Column(db.String(50), nullable=False)
estado = db.Column(db.String(2), nullable=False)
cep = db.Column(db.String(8), nullable=False)
complemento = db.Column(db.String(150))
telefone_fixo = db.Column(db.String(10))
celular = db.Column(db.String(11))
email = db.Column(db.String(150))
cod_fornecedor = db.Column(db.Integer,
db.ForeignKey('fornecedor.cod_fornecedor'))
def __init__(self, nome, logradouro, numero, bairro, cidade, estado, cep,
complemento, telefone_fixo, celular, email, cod_fornecedor):
self.nome = nome
self.logradouro = logradouro
self.numero = numero
self.bairro = bairro
self.cidade = cidade
self.estado = estado
self.cep = cep
self.complemento = complemento
self.telefone_fixo = telefone_fixo
self.celular = celular
self.email = email
self.cod_fornecedor = cod_fornecedor
def json(self):
return {
'cod_contato': self.cod_contato,
'nome': self.nome,
'logradouro': self.logradouro,
'numero': self.numero,
'bairro': self.bairro,
'cidade': self.cidade,
'estado': self.estado,
'cep': self.cep,
'complemento': self.complemento,
'telefone_fixo': self.telefone_fixo,
'celular': self.celular,
'email': self.email,
'cod_fornecedor': self.cod_fornecedor
}
@classmethod
def find_contato(cls, cod_contato):
fornecedor = cls.query.filter_by(cod_contato=cod_contato).first()
if fornecedor:
return fornecedor
return None
def save_contato(self):
db.session.add(self)
db.session.commit()
def update_contato(self, nome, logradouro, numero, bairro, cidade, estado,
cep, complemento, telefone_fixo, celular, email,
cod_fornecedor):
self.nome = nome
self.logradouro = logradouro
self.numero = numero
self.bairro = bairro
self.cidade = cidade
self.estado = estado
self.cep = cep
self.complemento = complemento
self.telefone_fixo = telefone_fixo
self.celular = celular
self.email = email
self.cod_fornecedor = cod_fornecedor
def delete_contato(self):
db.session.delete(self)
db.session.commit()
class HotelModel(db.Model):
__tablename__ = 'hoteis'
hotel_id = db.Column(db.String, primary_key=True)
name = db.Column(db.String(80))
rating = db.Column(db.Float(precision=1), )
daily = db.Column(db.Float(precision=2), )
city = db.Column(db.String(40), )
site_id = db.Column(db.Integer, db.ForeignKey('sites.site_id'))
def __init__(self, hotel_id, name, rating, daily, city, site_id):
self.hotel_id = hotel_id
self.name = name
self.rating = rating
self.daily = daily
self.city = city
self.site_id = site_id
def json(self):
return {
"hotel_id": self.hotel_id,
"name": self.name,
"rating": self.rating,
"daily": self.daily,
"city": self.city,
"site": self.site_id,
}
@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, name, rating, daily, city):
self.name = name
self.rating = rating
self.daily = daily
self.city = city
def delete_hotel(self):
db.session.delete(self)
db.session.commit()
@classmethod
def find(cls, **kwargs):
params = kwargs
connection = psycopg2.connect(user=USER, password=PASSWORD, host=HOST, port=PORT, database=DATABASE)
cursor = connection.cursor()
if not params.get("cidade"):
consulta = consulta_sem_cidade
# cond = tuple([params[chave] for chave in params])
# result = cursor.execute(consulta, (rating_min, rating_max, daily_min, daily_max, limit, offset))
# result = cursor.execute(consulta, cond)
else:
consulta = consulta_com_cidade
cond = tuple([params[chave] for chave in params])
cursor.execute(consulta, cond)
result = cursor.fetchall()
hoteis = []
for linha in result:
hoteis.append({
"hotel_id": linha[0],
"name": linha[1],
"rating": linha[2],
"daily": linha[3],
"city": linha[4],
"site_id": linha[5],
})
return hoteis
class BrandFoodModel(db.Model):
__tablename__ = 'brand_food'
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)
bar_code = db.Column(db.String(13),
nullable=False,
unique=True,
index=True)
brands = db.relationship('BrandModel', lazy='joined')
foods = db.relationship('FoodModel', lazy='joined')
def __init__(self, id_brand, id_food, bar_code):
self.id_brand = id_brand
self.id_food = id_food
self.bar_code = bar_code
def json(self):
return {
'brandId': self.id_brand,
'foodId': self.id_food,
'barCode': self.bar_code
}
def brand(self):
brand = self.brands.json()
return {
'barCode': self.bar_code,
'id': brand['id'],
'name': brand['name']
}
def food(self):
food = self.foods.json()
return {
'barCode': self.bar_code,
'id': food['id'],
'name': food['name']
}
@classmethod
def find_by_food(cls, food_id):
return cls.query.filter_by(id_food=food_id).order_by(
unaccent(text("food_1.name")))
@classmethod
def find_by_brand(cls, brand_id):
return cls.query.filter_by(id_brand=brand_id).order_by(
unaccent(text("brand_1.name")))
@classmethod
def find_by_id(cls, brand_id, food_id):
return cls.query.enable_eagerloads(False).filter_by(
id_brand=brand_id, id_food=food_id).first()
@classmethod
def find_by_bar_code(cls, bar_code):
return cls.query.enable_eagerloads(False).filter_by(
bar_code=bar_code).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 TestModel(db.Model):
__tablename__ = 'test'
id = db.Column(db.Integer, primary_key=True)
duration = db.Column(db.Integer)
fhr_value = db.Column(db.Float)
date_created=db.Column(db.DateTime(6),default=db.func.current_timestamp(),nullable=False)
identifier = db.Column(db.String(60), db.ForeignKey('monitoring.identifier'))
device_id = db.Column(db.String(30), db.ForeignKey('device.mac'))
status = db.Column(db.Boolean, default=0)
#device = bd.relationship('DeviceModel')
def __init__(self, duration, fhr_value, date_created, identifier, device_id):
self.duration=duration
self.fhr_value = fhr_value
if date_created==None:
self.date_created = date.today()
else:
self.date_created = date_created
self.identifier = identifier
self.device_id = device_id
self.status=0
def json(self):
return {
'duration': self.duration,
'fhr_value': self.fhr_value,
'identifier': self.identifier
}
@classmethod
def update_by_id(cls, id_list):
if not len(id_list)==0:
parametros = str(id_list)
parametros = (parametros.replace("[", " ", 2)).replace("]", " ", 2)
update_sql=f'update db.test set status=1 where id in ({parametros})'
try:
db.session.execute(update_sql)
db.session.commit()
return True
except Exception as e:
db.session.rollback()
return False
@classmethod
def find_by_date(cls, date_created):
test = cls.query.filter_by(date_created=date_created).all()
if test:
return test
return None
@classmethod
def find_by_identifier(cls, identifier):
test = cls.query.filter_by(identifier=identifier).all()
if test:
return test
return None
@classmethod
def find_by_list(cls, list_id, limit=None):
if not limit==None:
tests = cls.query.order_by(asc(cls.identifier), cls.duration).filter(and_(cls.identifier.in_(list_id), cls.status==0, cls.date_created==str(date.today()))).limit(limit).all()
else:
tests = cls.query.order_by(asc(cls.identifier), cls.duration).filter(and_(cls.identifier.in_(list_id), cls.status==0, cls.date_created==str(date.today()))).all()
return tests
def save(self):
db.session.add(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()