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 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 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 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 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 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 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 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(80))
def __init__(self, hotel_id, **kwargs):
self.hotel_id = hotel_id
self.nome = kwargs.get('nome')
self.estrelas = kwargs.get('estrelas')
self.diaria = kwargs.get('diaria')
self.cidade = kwargs.get('cidade')
def serialize(self):
return {
'hotel_id': self.hotel_id,
'nome': self.nome,
'estrelas': self.estrelas,
'diaria': self.diaria,
'cidade': self.cidade
}
@classmethod
def get_or_none(cls, hotel_id):
return cls.query.filter_by(hotel_id=hotel_id).first()
@classmethod
def get_queryset(cls, **kwargs):
queryset = cls.query
nome = kwargs.get('nome', '')
if nome:
queryset = queryset.filter_by(nome=nome)
return queryset.all()
def _save_instance(self):
db.session.add(self)
db.session.commit()
@classmethod
def perform_save(cls, hotel_id, **data):
new_hotel = cls(hotel_id, **data)
new_hotel._save_instance()
return new_hotel
def perform_update(self, **data):
self.nome = data.get("nome")
self.estrelas = data.get("estrelas")
self.diaria = data.get("diaria")
self.cidade = data.get("cidade")
self._save_instance()
def remove(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 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 BudgetingModel(db.Model):
__tablename__ = "budgeting"
id = db.Column(db.Integer, autoincrement=True, primary_key=True)
name = db.Column(db.String(255))
totalCost = db.Column(db.Float(precision=2))
periodEnum = db.Column(db.String(10))
currencyEnum = db.Column(db.String(6))
effectiveFrom = db.Column(db.Date())
effectiveTo = db.Column(db.Date())
description = db.Column(db.String(255))
paymentTypeEnum = db.Column(db.String(10))
microServices = db.relationship("MicroServiceModel", cascade="all")
running = db.Column(db.String(3), default="NO")
creation = db.Column(db.Date(), server_default=sqlalchemy.sql.func.now())
def __init__(self, name, totalCost, periodEnum, currencyEnum,
effectiveFrom, effectiveTo, description, paymentTypeEnum,
microServices: List[MicroServiceModel]):
self.name = name
self.totalCost = totalCost
self.periodEnum = periodEnum
self.currencyEnum = currencyEnum
self.effectiveFrom = effectiveFrom
self.effectiveTo = effectiveTo
self.description = description
self.paymentTypeEnum = paymentTypeEnum
self.microServices = microServices
def json(self):
return {
"id":
self.id,
"name":
self.name,
"totalCost":
self.totalCost,
"periodEnum":
self.periodEnum,
"currencyEnum":
self.currencyEnum,
"effectiveFrom":
str(self.effectiveFrom),
"effectiveTo":
str(self.effectiveTo),
"description":
self.description,
"paymentTypeEnum":
self.paymentTypeEnum,
"running":
self.running,
"creation":
str(self.creation),
"microServices":
[microService.json() for microService in self.microServices]
}
@classmethod
def find_budgeting(cls, id):
budgeting = cls.query.filter_by(
id=id).first() # select * from budgeting where id = $id
if budgeting:
return budgeting
return None
@classmethod
def find_by_running_scenario(cls):
budgeting = cls.query.filter_by(running="YES").first(
) # select * from budgeting where running = YES
if budgeting:
return budgeting
return None
def save_budgeting(self):
db.session.add(self)
db.session.commit()
def update_scenario_budgeting(self, running):
self.running = running
def delete_budgeting(self):
db.session.delete(self)
db.session.commit()
