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 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 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 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 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 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 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 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 UserModel(db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
login = db.Column(db.String(40), nullable=False, unique=True)
password = db.Column(db.String(200), nullable=False)
organization_key = db.Column(db.String(200))
email = db.Column(db.String(100), nullable=False, unique=True)
actived = db.Column(db.Boolean, default=False)
def __init__(self, login, password, organization_key, email, actived):
self.login = login
self.password = password
self.organization_key = organization_key
self.email = email
self.actived = actived
def json(self):
return {
'login': self.login,
'organization_key': self.organization_key,
'email': self.email,
'actived': self.actived
}
@classmethod
def find_user(cls, id):
user = cls.query.filter_by(id=id).first()
print(user.actived)
if user:
return user
return None
@classmethod
def find_by_login(cls, organization_key):
user = cls.query.filter_by(organization_key=organization_key).first()
if user:
return user
return None
@classmethod
def find_by_email(cls, email):
user = cls.query.filter_by(email=email).first()
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 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 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 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 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 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 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 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 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()
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 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 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 VendedorModel(db.Model):
__tablename__ = 'vendedor'
cod_vendedor = db.Column(db.Integer, primary_key=True)
nome_vendedor = db.Column(db.String(150))
login = db.Column(db.String(50), nullable=False)
senha = db.Column(db.String(50), nullable=False)
ativo = db.Column(db.Boolean, default=True)
def __init__(self, nome_vendedor, login, senha, ativo):
self.nome_vendedor = nome_vendedor
self.login = login
self.senha = senha
self.ativo = ativo
def json(self):
return {
'cod_vendedor': self.cod_vendedor,
'nome_vendedor': self.nome_vendedor,
'login': self.login,
'ativo': self.ativo
}
def jsonPut(self):
return {
'cod_vendedor': self.cod_vendedor,
'nome_vendedor': self.nome_vendedor,
'login': self.login,
'senha': self.senha,
'ativo': self.ativo
}
@classmethod
def find_vendedor(cls, cod_vendedor):
vendedor = cls.query.filter_by(cod_vendedor=cod_vendedor).first()
if vendedor:
return vendedor
return None
@classmethod
def find_by_login(cls, login):
vendedor = cls.query.filter_by(login=login).first()
if vendedor:
return vendedor
return None
def save_vendedor(self):
db.session.add(self)
db.session.commit()
def update_vendedor(self, cod_vendedor, nome_vendedor, login, senha,
ativo):
self.cod_vendedor = cod_vendedor
self.nome_vendedor = nome_vendedor
self.login = login
self.senha = senha
self.ativo = ativo
def delete_vendedor(self):
db.session.delete(self)
db.session.commit()
class UserModel(db.Model):
__tablename__ = 'users'
userId = db.Column(db.Integer, primary_key=True)
login = db.Column(db.String(40), nullable=False, unique=True)
email = db.Column(db.String, nullable=False, unique=True)
password = db.Column(db.String, nullable=False)
confirmed = db.Column(db.Boolean, default=False)
adminconfirmed = db.Column(db.Boolean, default=False)
def __init__(self, login, email, password, confirmed, adminconfirmed):
self.login = login
self.email = email
self.password = password
self.confirmed = confirmed
self.adminconfirmed = adminconfirmed
def send_confirmation_email(self):
link = request.url_root[:-1] + url_for('userconfirmed', userId=self.userId)
return post('https://api.mailgun.net/v3/{}/messages'.format(MAILGUN_DOMAIN),
auth=('api', '{}'.format(MAILGUN_API_KEY)),
data={'from': '{} <{}>'.format(FROM_TITLE, FROM_EMAIL),
'to': self.email,
'subject': 'Register confirmation',
'text': 'Confirm your registration by clicking on the link: {}'.format(link),
'html': '<html><p>\
Confirm your registration by clicking on the link: <a href="{}">Confirm Email</a>\
</p></html>'.format(link)
}
)
def json(self):
return {
'userId': self.userId,
'login': self.login,
'email': self.email,
'confirmed': self.confirmed,
'adminconfirmed': self.adminconfirmed
}
@classmethod
def find_user(cls, userId):
user = cls.query.filter_by(userId=userId).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
@classmethod
def find_by_email(cls, email):
user = cls.query.filter_by(email=email).first()
if user:
return user
return None
@classmethod
def check_password(cls, email):
user = cls.query.filter_by(email=email).first()
if user:
return user.password
return None
def save_user(self):
db.session.add(self)
db.session.commit()
def delete_user(self):
db.session.delete(self)
db.session.commit()
