class HotelModel(banco.Model):
__tablename__ = "hoteis"
hotel_id = banco.Column(banco.Float, primary_key=True)
nome = banco.Column(banco.String(80))
estrelas = banco.Column(banco.Float(precision=1))
diaria = banco.Column(banco.Float(precision=2))
cidade = banco.Column(banco.String(90))
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
}
class ContaModel(banco.Model):
__tablename__ = 'usuarios'
user_id = banco.Column(banco.Integer, primary_key=True)
user_ip = banco.Column(banco.String(20))
user_resoluction= banco.Column(banco.String(9))
status = banco.Column(banco.Integer)
def __init__(self, user_ip, user_resoluction, status):
self.user_ip = user_ip
self.user_resoluction = user_resoluction
self.status = status
def json(self):
return {
'user_ip': self.user_ip,
'user_resoluction': self.user_resoluction,
'status': self.status
}
@classmethod
def seach(cls, user_ip):
user = cls.query.filter_by(user_ip=user_ip).first()
if user:
return user
return None
def save_user(self):
banco.session.add(self)
banco.session.commit()
def update_user(self, status):
self.status = status
class HotelModel(banco.Model):
__tablename__ = 'hoteis'
hotel_id = banco.Column(banco.String, primary_key=True)
nome = banco.Column(banco.String(80))
estrelas = banco.Column(banco.Float(precision=1))
diaria = banco.Column(banco.Float(precision=2))
cidade = banco.Column(banco.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() # SELECT * FROM hoteis WHERE hotel_id = hotel_id
if hotel:
return hotel
return None
def save_hotel(self):
banco.session.add(self)
banco.session.commit()
class UserModel(banco.Model):
__tablename__ = 'usuarios'
user = banco.Column(banco.Integer, primary_key=True)
login = banco.Column(banco.String(40))
senha = banco.Column(banco.String(40))
def __init__(self, login, senha):
self.login = login
self.senha = senha
def json(self):
return {'user_id': self.user_id, '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):
banco.session.add(self)
banco.session.commit()
def delete_user(self):
banco.session.delete(self)
banco.session.commit()
class UsuarioModel(banco.Model):
__tablename__ = 'usuario'
__API_KEY = '7644cf468d58a38c49c7de945cd8b7d7-f135b0f1-0a2e4de9'
__MAIL_GUN = 'sandbox0e86c238eda544aebc646476abfcf410.mailgun.org'
__FROM_TITLE = 'NO-REPLY'
__FROM_EMAIL = '*****@*****.**'
user_id = banco.Column(banco.Integer, primary_key=True)
login = banco.Column(banco.String(40), nullable=False, unique=True)
senha = banco.Column(banco.String(40))
email = banco.Column(banco.String(80), nullable=False, unique=True)
ativado = banco.Column(banco.Boolean, default=False)
def __init__(self, login, senha, email, ativado):
self.login = login
self.senha = senha
self.email = email
self.ativado = ativado
def send_confirmation_email(self):
# http://localhost:5000/confirmacao
link = request.url_root[:-1] + url_for('userconfirm',
user_id=self.user_id)
return post(f'https://api.mailgun.net/v3/{self.__MAIL_GUN}/messages',
auth=('api', self.__API_KEY),
data={
"from": f"{self.__FROM_TITLE} <{self.__FROM_EMAIL}>",
"to": self.email,
"subject": "Confirmaço de Cadastro",
"text": f"Confirme seu cadastro no link: {link}"
})
def json(self):
return {
"user_id": self.user_id,
"login": self.login,
"email": self.email,
"ativado": self.ativado
}
@classmethod
def find(cls, user_id):
return cls.query.filter_by(user_id=user_id).first()
@classmethod
def find_by_login(cls, login):
return cls.query.filter_by(login=login).first()
@classmethod
def find_by_email(cls, email):
return cls.query.filter_by(email=email).first()
def save(self):
banco.session.add(self)
banco.session.commit()
def delete(self):
banco.session.delete(self)
banco.session.commit()
class HotelModel(banco.Model):
"""Classe para referenciar os hoteis"""
__tablename__ = 'hoteis'
hotel_id = banco.Column(banco.String, primary_key=True)
nome = banco.Column(banco.String(80)) # 80 tamanho sting
estrelas = banco.Column(banco.Float(precision=2))
diaria = banco.Column(banco.Float(precision=2))
cidade = banco.Column(banco.String(40))
audio = banco.Column(banco.String(8000))
# construtor
def __init__(self, hotel_id, nome, estrelas, diaria, cidade, audio):
self.hotel_id = hotel_id
self.nome = nome
self.estrelas = estrelas
self.diaria = diaria
self.cidade = cidade
self.audio = audio
# metodo de classe pois le não vai acessar nenhum atributos do objeto, apenas id, que sera passado por argumento
@classmethod
def find_hotel(cls, hotel_id):
hotel = cls.query.filter_by(hotel_id=hotel_id).first(
) # SELECT * FROM hoteis WHERE hotel_id = $hotel_id LIMIT 1
if hotel:
return hotel
return None
def save_hotel(self):
#salva pro db , sabendo os argumentos do obj
banco.session.add(self)
banco.session.commit()
def update_hotel(self, nome, estrelas, diaria, cidade,
audio): # atributos vindo do **dados
self.nome = nome
self.estrelas = estrelas
self.diaria = diaria
self.cidade = cidade
self.audio = audio
def delete_hotel(self):
"""deleta hotel"""
#recebe o objeto e deleta do banco
banco.session.delete(self)
banco.session.commit()
def json(self):
"""metodo que transforma objeto em json"""
return {
'hotel_id': self.hotel_id,
'nome': self.nome,
'estrelas': self.estrelas,
'diaria': self.diaria,
'cidade': self.cidade,
#não retornar aqui pois não é serializavel
#'audio':self.audio
}
class HotelModel(banco.Model):
__tablename__ = 'hoteis'
hotel_id = banco.Column(banco.String(30), primary_key=True)
nome = banco.Column(banco.String(80))
estrelas = banco.Column(banco.Float(precision=1))
diaria = banco.Column(banco.Float(precision=2))
cidade = banco.Column(banco.String(40))
site_id = banco.Column(banco.Integer, banco.ForeignKey('sites.site_id'))
#site = banco.relashionship('SiteModel')
def __init__(self, hotel_id, nome, estrelas, diaria, cidade, site_id):
self.hotel_id = hotel_id
self.nome = nome
self.estrelas = estrelas
self.diaria = diaria
self.cidade = cidade
self.site_id = site_id
#S
#converte em json
def json(self):
return {
'hotel_id': self.hotel_id,
'nome': self.nome,
'estrelas': self.estrelas,
'diaria': self.diaria,
'cidade': self.cidade,
'site_id': self.site_id
}
@classmethod
def find_hotel(cls, hotel_id):
hotel = cls.query.filter_by(
hotel_id=hotel_id).first() #select * from w
if hotel:
return hotel
return None
@classmethod
def find_hoteis(cls):
hoteis = cls.query.all() #select * from
return hoteis
def save_hotel(self):
banco.session.add(self)
banco.session.commit()
def update(self, nome, estrelas, diaria, cidade):
self.nome = nome
self.estrelas = estrelas
self.diaria = diaria
self.cidade = cidade
def delete(self):
banco.session.delete(self)
banco.session.commit()
class HotelModel(banco.Model):
__tablename__ = 'hotels'
id = banco.Column(banco.Integer, primary_key=True, autoincrement=True)
name = banco.Column(banco.String(80))
stars = banco.Column(banco.Float(precision=1))
daily = banco.Column(banco.Float(precision=2))
state = banco.Column(banco.String(80))
city = banco.Column(banco.String(80))
site_id = banco.Column(banco.Integer, banco.ForeignKey('sites.id'))
def __init__(self, name, stars, daily, state, city, site_id):
self.name = name
self.stars = stars
self.daily = daily
self.state = state
self.city = city
self.site_id = site_id
def json(self):
return {
'id': self.id,
'name': self.name,
'stars': self.stars,
'daily': self.daily,
'state': self.state,
'city': self.city,
'site_id': self.site_id
}
@classmethod
def hotel_find_by_name(cls, name):
hotel = cls.query.filter_by(name=name).first()
if hotel:
return hotel
return None
@classmethod
def hotel_find_by_id(cls, id):
hotel = cls.query.filter_by(id=id).first()
if hotel:
return hotel
return None
def save_hotel(self):
banco.session.add(self)
banco.session.commit()
def update_hotel(self, name, stars, daily, state, city, site_id):
self.name = name
self.stars = stars
self.daily = daily
self.state = state
self.city = city
self.site_id = site_id
def delete_hotel(self):
banco.session.delete(self)
banco.session.commit()
class HotelModel(banco.Model):
__tablename__ = 'hoteis'
hotel_pk = banco.Column(banco.Integer, primary_key=True)
hotel_id = banco.Column(banco.String)
nome = banco.Column(banco.String(80))
estrelas = banco.Column(banco.Float(precision=1))
diaria = banco.Column(banco.Float(precision=2))
cidade = banco.Column(banco.String(40))
site_id = banco.Column(banco.Integer, banco.ForeignKey('sites.site_id'))
def __init__(self, hotel_id, nome, estrelas, diaria, cidade, site_id):
self.hotel_id = hotel_id
self.nome = nome
self.estrelas = estrelas
self.diaria = diaria
self.cidade = cidade
self.site_id = site_id
def json(self):
return {
'hotel_id': self.hotel_id,
'nome': self.nome,
'estrelas': self.estrelas,
'diaria': self.diaria,
'cidade': self.cidade,
'site_id': self.site_id
}
@classmethod
def find_hotel(cls, hotel_id):
hotel = cls.query.filter_by(hotel_id=hotel_id).first(
) #SELECT * FROM hoteis where hotel_id = hotel_id limmit 1
if hotel:
return hotel
@classmethod
def find_hotel_by_site_id(cls, site_id):
hotel = cls.query.filter_by(site_id=site_id).first(
) #SELECT * FROM hoteis where hotel_id = hotel_id limmit 1
if hotel:
return hotel
def save_hotel(self):
banco.session.add(self)
banco.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):
banco.session.delete(self)
banco.session.commit()
class RotaModel(banco.Model):
__tablename__ = 'rotas'
rota_id = banco.Column(banco.Integer, primary_key=True)
caminhoneiro_id = banco.Column(banco.Integer)
origem = banco.Column(banco.String(80))
destino = banco.Column(banco.String(80))
data_partida = banco.Column(banco.String(80))
tipo_veiculo = banco.Column(banco.Integer,
banco.ForeignKey('veiculos.codigo'))
carregado = banco.Column(banco.String(3))
def __init__(self, caminhoneiro_id, origem, destino, data_partida,
tipo_veiculo, carregado):
self.caminhoneiro_id = caminhoneiro_id
self.origem = origem
self.destino = destino
self.data_partida = data_partida
self.tipo_veiculo = tipo_veiculo
self.carregado = carregado
def json(self):
return {
'rota_id': self.rota_id,
'caminhoneiro_id': self.caminhoneiro_id,
'origem': self.origem,
'destino': self.destino,
'data_partida': self.data_partida,
'tipo_veiculo': self.tipo_veiculo,
'carregado': self.carregado
}
@classmethod
def find_rota(cls, rota_id):
rota = cls.query.filter_by(rota_id=rota_id).first()
if rota:
return rota
return None
def save_rota(self):
banco.session.add(self)
banco.session.commit()
def update_rota(self, caminhoneiro_id, origem, destino, data_partida,
tipo_veiculo, carregado):
self.caminhoneiro_id = caminhoneiro_id
self.origem = origem
self.destino = destino
self.data_partida = datetime.strptime(data_partida, '%Y-%m-%d %H:%M')
self.tipo_veiculo = tipo_veiculo
self.carregado = carregado
def delete_rota(self):
banco.session.delete(self)
banco.session.commit()
class HotelModel(banco.Model): #define que cada nome será uma coluna
__tablename__ = 'hotel'
#representa o modelo no banco
hotel_id = banco.Column(banco.String, primary_key=True)
nome = banco.Column(banco.String(80))
estrelas = banco.Column(banco.Float(precision=1))
diaria = banco.Column(banco.Float(precision=1))
cidade = banco.Column(banco.String(40))
site_id = banco.Column(banco.Integer, banco.FereingKey('sites.site_id'))
#site = banco.relationship('SiteModel')
#init da classe
def __init__(self, hotel_id, nome, estrelas, diaria, cidade, site_id):
self.hotel_id = hotel_id
self.nome = nome
self.estrelas = estrelas
self.diaria = diaria
self.cidade = cidade
self.site_id = site_id
#transforma em dict
def json(self):
return {
'hotel_id': self.hotel_id,
'nome': self.nome,
'estrelas': self.estrelas,
'diaria': self.diaria,
'cidade': self.cidade,
'site_id': self.site_id
}
@classmethod
def find_hotel(cls, hotel_id):
#cls pega metodo da classe, metodo presente na classe estendiada banco.Model
hotel = cls.query.filter_by(hotel_id=hotel_id).first(
) #SELECT * FROM hoteis WHERE hotel_id==hotel_id limite=1
if hotel:
return hotel
return False
def save_hotel(self): #sava os dados no bd
banco.session.add(self)
banco.session.commit()
def update_hotel(self, nome, estrelas, diaria,
cidade): #update dos dados pra classe
self.nome = nome
self.estrelas = estrelas
self.diaria = diaria
self.cidade = cidade
def delete_hotel(self):
banco.session.delete(self)
banco.session.commit()
class UserModel(banco.Model):
__tablename__ = 'usuarios'
id_user = banco.Column(banco.Integer, primary_key=True)
nome = banco.Column(banco.String(40))
matricula = banco.Column(banco.Integer)
email = banco.Column(banco.String(40), unique=True)
senha = banco.Column(banco.String(40))
curso = banco.Column(banco.Integer)
def __init__(self, nome, matricula, email, senha, curso):
self.nome = nome
self.matricula = matricula
self.email = email
self.senha = senha
self.curso = curso
def json(self):
return {
'id_user': self.id_user,
'nome': self.nome,
'matricula': self.matricula,
'email': self.email,
'senha': self.senha, #futuramente tirar esse atributo de impressão
'curso': self.curso
}
@classmethod
def find_user(cls, email):
user = cls.query.filter_by(email=email).first()
if user:
return user
return None
@classmethod
def find_by_id_user(cls, id_user):
user = cls.query.filter_by(id_user=id_user).first()
if user:
return user
return None
def save_user(self):
banco.session.add(self)
banco.session.commit()
def delete_user(self):
banco.session.delete(self)
banco.session.commit()
def update_user(self, nome, matricula, email, senha, curso):
self.nome = nome
self.matricula = matricula
self.email = email
self.senha = senha
self.curso = curso
class HotelModel(banco.Model):
__tablename__ = 'hoteis'
hotel_id = banco.Column(banco.String, primary_key=True)
nome = banco.Column(banco.String(80))
estrelas = banco.Column(banco.Float(precision=1))
diaria = banco.Column(banco.Float(precision=2))
cidade = banco.Column(banco.String(40))
site_id = banco.Column(banco.Integer, banco.ForeignKey('sites.site_id'))
#site = banco.relationship('SiteModel')
# Cria os campos do modelo da classe hotel >>Isso é um objeto<<
def __init__(self, hotel_id, nome, estrelas, diaria, cidade, site_id):
self.hotel_id = hotel_id
self.nome = nome
self.estrelas = estrelas
self.diaria = diaria
self.cidade = cidade
self.site_id = site_id
# Funcão que Transforma um objeto em um fomato DICIONÁRIO que converte/ou é um JSON - automaticamente >>> <<<
def json(self):
return {
'hotel_id': self.hotel_id,
'nome': self.nome,
'estrelas': self.estrelas,
'diaria': self.diaria,
'cidade': self.cidade,
'site_id': 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):
banco.session.add(self)
banco.session.commit()
def update_hotel(self, nome, estrelas, diaria, cidade, site_id):
self.nome = nome
self.estrelas = estrelas
self.diaria = diaria
self.cidade = cidade
self.site_id = site_id
def delete_hotel(self):
banco.session.delete(self)
banco.session.commit()
class HotelModel(banco.Model):
__tablename__ = 'hotel'
id = banco.Column(banco.String, primary_key=True)
nome = banco.Column(banco.String(80))
estrelas = banco.Column(banco.Float(precision=1))
diaria = banco.Column(banco.Float(precision=2))
cidade = banco.Column(banco.String(40))
site_id = banco.Column(banco.Integer, banco.ForeignKey('site.id'))
def __init__(self, id, nome, estrelas, diaria, cidade, site_id):
self.id = id
self.nome = nome
self.estrelas = estrelas
self.diaria = diaria
self.cidade = cidade
self.site_id = site_id
def json(self):
return {
'id': self.id,
'nome': self.nome,
'estrelas': self.estrelas,
'diaria': self.diaria,
'cidade': self.cidade,
'site_id': self.site_id
}
#cls define que o método é um 'método de classe', portanto não acessa as propriedades self
@classmethod
def find(cls, id):
hotel = cls.query.filter_by(id=id).first()
return hotel if hotel else None
@classmethod
def find_all(cls):
hoteis = cls.query.all()
return hoteis
def save(self):
banco.session.add(self)
banco.session.commit()
def update(self, nome, estrelas, diaria, cidade, site_id):
self.nome = nome
self.estrelas = estrelas
self.diaria = diaria
self.cidade = cidade
self.site_id = site_id
self.save()
def delete(self):
banco.session.delete(self)
banco.session.commit()
class ClientModel(banco.Model):
__tablename__ = 'clients'
#client_id = banco.Column(banco.Integer, primary_key=True)
name = banco.Column(banco.String(40))
email = banco.Column(banco.String(40), primary_key=True)
productList = banco.Column(banco.JSON)
def __init__(
self, productList, name,
email): #não passa o id e o sistema vai incrementando ao ver vazio
self.name = name
self.email = email
self.productList = productList
def json(self):
return {
'login': self.name,
'email': self.email,
'productList': self.productList
}
@classmethod
def find_by_email(
cls, email): #cls é a mesma coisa de escrever HotelModel poe ex
user = cls.query.filter_by(email=email).first(
) #faz uma consulta usando um método de banco.Model
#SELECT * FROM hotels WHERE hotel_id=$hotel_id LIMIT 1
if user:
return user
return None
def insertClient(self):
banco.session.add(self)
banco.session.commit()
def updateClient(self, name):
self.name = name
def updateProductList(self, price, image, brand, id, title, reviewScore):
newProductList = copy.deepcopy(self.productList)
newProductList[id] = {
"price": price,
"image": image,
"brand": brand,
"title": title,
"reviewScore": reviewScore
}
self.productList = copy.deepcopy(newProductList)
#print(self.productList)
def deleteClient(self):
banco.session.delete(self)
banco.session.commit()
class ChamadaModel(banco.Model):
__tablename__ = 'chamadas'
chamada_id = banco.Column(banco.String, primary_key=True)
nome = banco.Column(banco.String(80))
cpf = banco.Column(banco.Integer())
endereco = banco.Column(banco.String())
telefone = banco.Column(banco.Integer())
cell = banco.Column(banco.Integer())
email = banco.Column(banco.String())
def __init__(self, chamada_id, nome, cpf, endereco, telefone, cell, email):
self.chamada_id = chamada_id
self.nome = nome
self.cpf = cpf
self.endereco = endereco
self.telefone = telefone
self.cell = cell
self.email = email
def json(self):
return {
'chamada_id': self.chamada_id,
'nome': self.nome,
'cpf': self.cpf,
'endereco': self.endereco,
'telefone': self.telefone,
'cell': self.cell,
'email': self.email
}
@classmethod
def find_chamada(cls, chamada_id):
chamada = cls.query.filter_by(chamada_id=chamada_id).first()
if chamada:
return chamada
return None
def save_chamada(self):
banco.session.add(self)
banco.session.commit()
def update_chamada(self, nome, cpf, endereco, telefone, cell, email):
self.nome = nome
self.cpf = cpf
self.endereco = endereco
self.telefone = telefone
self.cell = cell
self.email = email
def delete_chamada(self):
banco.session.delete(self)
banco.session.commit()
class HotelModel(banco.Model):
__tablename__ = 'hoteis'
hotel_id = banco.Column(
banco.String, primary_key=True
) #criando as tabelas do meu banco, definindo a estrutura e os tipos
nome = banco.Column(banco.String(80))
estrelas = banco.Column(banco.Float(precision=1)) #quantas casas decimais
diaria = banco.Column(banco.Float(precision=2))
cidade = banco.Column(banco.String(40))
def __init__(self, hotel_id, nome, estrelas, diaria,
cidade): #criando o construtor para hotel
self.hotel_id = hotel_id
self.nome = nome
self.estrelas = estrelas
self.diaria = diaria
self.cidade = cidade
def json(self): #função para converter o objeto em JSON
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(
) #seleciona todo os dados do cria_banco [select *from hoteis where hotel_id = hotel_id]
if hotel: #first== limit 1
return hotel
return None
def save_hotel(self):
banco.session.add(
self
) #ele vai saber quais argumentos a gente passou pra ele e vai salvar
banco.session.commit(
) #vai fazer o commit, que sifnifica fim do processo
def update_hotel(self, nome, estrelas, diaria, cidade):
self.nome = nome
self.estrelas = estrelas
self.diaria = diaria
self.cidade = cidade
def delete_hotel(self):
banco.session.delete(self)
banco.session.commit()
class HotelModel(banco.Model):
__tablename__ = 'hoteis'
hotel_id = banco.Column(banco.String, primary_key=True)
nome = banco.Column(banco.String(80))
estrelas = banco.Column(banco.Float(precision=1))
diaria = banco.Column(banco.Float(precision=2))
cidade = banco.Column(banco.String(40))
site_id = banco.Column(banco.Integer, banco.ForeignKey('sites.site_id'))
# site = banco.relationship('SiteModel') #Retorna uma lista de sites?
def __init__(self, hotel_id, nome, estrelas, diaria, cidade, site_id):
self.hotel_id = hotel_id
self.nome = nome
self.estrelas = estrelas
self.diaria = diaria
self.cidade = cidade
self.site_id = site_id
def json(self):
return {
"hotel_id": self.hotel_id,
"nome": self.nome,
"estrelas": self.estrelas,
"diaria": self.diaria,
"cidade": self.cidade,
"site_id": self.site_id
}
@classmethod
def find_hotel(cls, hotel_id):
# SELECT * FROM hoteis WHERE hotel_id=hotel_id
hotel = cls.query.filter_by(hotel_id=hotel_id).first()
if hotel:
return hotel
return None
def save_hotel(self):
banco.session.add(self)
banco.session.commit()
def update_hotel(self, nome, estrelas, diaria, cidade, site_id):
self.nome = nome
self.estrelas = estrelas
self.diaria = diaria
self.cidade = cidade
self.site_id = site_id
def delete_hotel(self):
banco.session.delete(self)
banco.session.commit()
class HotelModel(banco.Model):
__tablename__ = 'hoteis' # nome da tabela
# mapeia os elementos do objeto em colunas do banco
hotel_id = banco.Column(banco.String, primary_key=True)
nome = banco.Column(banco.String(80))
estrelas = banco.Column(banco.Float(precision=1))
diaria = banco.Column(banco.Float(precision=2))
cidade = banco.Column(banco.String(40))
# construtor do modelo de objeto
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):
# converte objeto recem criado para formato json
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):
# SELECT * FROM hoteis WHERE hotel_id = $hotel_id LIMIT 1
hotel = cls.query.filter_by(hotel_id=hotel_id).first()
if hotel:
return hotel
return None
def save_hotel(self):
banco.session.add(self)
banco.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):
banco.session.delete(self)
banco.session.commit()
class HotelModel(banco.Model):
__tablename__ = 'hoteis'
hotel_id = banco.Column(banco.String, primary_key=True)
nome = banco.Column(banco.String(80))
estrelas = banco.Column(banco.Float(precision=1))
diaria = banco.Column(banco.Float(precision=2))
cidade = banco.Column(banco.String(80))
site_id = banco.Column(banco.Integer, banco.ForeignKey('sites.site_id'))
# Construtor da classe, que irá retornar um objeto do tipo hotel
def __init__(self, hotel_id, nome, estrelas, diaria, cidade, site_id):
self.hotel_id = hotel_id
self.nome = nome
self.estrelas = estrelas
self.diaria = diaria
self.cidade = cidade
self.site_id = site_id
# Método pega o objeto e o retorna no formato json
def toJson(self):
return {
"hotel_id": self.hotel_id,
"nome": self.nome,
"estrelas": self.estrelas,
"diaria": self.diaria,
"cidade": self.cidade,
"site_id": 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):
banco.session.add(self)
banco.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):
banco.session.delete(self)
banco.session.commit()
class UserModel(banco.Model):
__tablename__ = 'usuarios'
user_id = banco.Column(banco.Integer, primary_key=True)
login = banco.Column(banco.String(40), nullable=False, unique=True)
senha = banco.Column(banco.String(40), nullable=False)
email = banco.Column(banco.String(80), nullable=False, unique=True)
ativado = banco.Column(banco.Boolean, default=False)
def __init__(
self, login, senha, email, ativado
): # não passando o user_id, sabendo que é Integer e PK, ele incrementa automaticamente
self.login = login
self.senha = senha
self.ativado = ativado
def send_confirmation_email(self):
# http://127.0.0.1:5000/confirmacao/{user_id}
link = request.url_root[:-1] + url_for('userconfirm',
user_id=self.user_id)
def json(self):
return {
'user_id': self.user_id,
'login': self.login,
'login': self.email,
'ativado': self.ativado
}
@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):
login = cls.query.filter_by(login=login).first()
if login:
return login
return None
def save_user(self):
banco.session.add(self)
banco.session.commit()
def delete_user(self):
banco.session.delete(self)
banco.session.commit()
class HotelModel(banco.Model):
__tablename__ = "hoteis"
hotel_id = banco.Column(banco.String, primary_key=True)
name = banco.Column(banco.String(80))
estrelas = banco.Column(banco.Float(precision=1))
diaria = banco.Column(banco.Float(precision=2))
cidade = banco.Column(banco.String(40))
site_id = banco.Column(banco.Integer, banco.ForeignKey('sites.site_id'))
def __init__(self, hotel_id, name, estrelas, diaria, cidade, site_id):
self.hotel_id = hotel_id
self.name = name
self.estrelas = estrelas
self.diaria = diaria
self.cidade = cidade
self.site_id = site_id
@classmethod
def findHotel(cls, hotel_id):
# SELECT * FROM hoteis WHERE hotel_id = hotel_id
hotel = cls.query.filter_by(hotel_id=hotel_id).first()
if hotel:
return hotel
return None
def save_hotel(self):
banco.session.add(self) #add the self object
banco.session.commit()
def update_hotel(self, name, estrelas, diaria, cidade, site_id):
self.name = name
self.estrelas = estrelas
self.diaria = diaria
self.cidade = cidade
self.site_id = site_id
def delete_hotel(self):
banco.session.delete(self)
banco.session.commit()
def json(self):
return {
'hotel_id': self.hotel_id,
'name': self.name,
'estrelas': self.estrelas,
'diaria': self.diaria,
'cidade': self.cidade,
'site_id': self.site_id
}
class SiteModel(banco.Model):
__tablename__ = 'sites'
id = banco.Column(banco.Integer, primary_key=True, autoincrement=True)
name = banco.Column(banco.String(80), nullable=False)
url = banco.Column(banco.String(80), nullable=False)
hotels = banco.relationship('HotelModel')
def __init__(self, name, url):
self.name = name
self.url = url
def json(self):
return {
'id': self.id,
'name': self.name,
'url': self.url,
'hotels': [hotel.json() for hotel in self.hotels]
}
@classmethod
def find_site_by_id(cls, id):
site = cls.query.filter_by(id=id).first()
if site:
return site
return None
@classmethod
def find_site_by_name(cls, name):
site = cls.query.filter_by(name=name).first()
if site:
return site
return None
@classmethod
def find_site_by_url(cls, url):
site = cls.query.filter_by(url=url).first()
if site:
return site
return None
def save_site(self):
banco.session.add(self)
banco.session.commit()
def delete_site(self):
[hotel.delete_hotel() for hotel in self.hotels]
banco.session.delete(self)
banco.session.commit()
class CobrancaModel(banco.Model):
__tablename__ = 'cobrancas'
cobranca_id = banco.Column(banco.Integer, primary_key=True)
cobranca_nome = banco.Column(banco.String(30))
cobranca_descricao = banco.Column(banco.String(200))
cobranca_remetente = banco.Column(banco.String(50))
cobranca_valor = banco.Column(banco.Float())
def __init__(self, cobranca_nome, cobranca_descricao, cobranca_remetente,
cobranca_valor):
self.cobranca_nome = cobranca_nome
self.cobranca_descricao = cobranca_descricao
self.cobranca_remetente = cobranca_remetente
self.cobranca_valor = cobranca_valor
def json(self):
return {
'cobranca_id': self.cobranca_id,
'cobranca_nome': self.cobranca_nome,
'cobranca_descricao': self.cobranca_descricao,
'cobranca_remetente': self.cobranca_remetente,
'cobranca_valor': self.cobranca_valor
}
@classmethod
def achar_cobranca(cls, cobranca_id):
cobranca = cls.query.filter_by(cobranca_id=cobranca_id).first()
if cobranca:
return cobranca
return None
def salvar_cobranca(self):
banco.session.add(self)
banco.session.commit()
def atualizar_cobranca(self, cobranca_banco, cobranca_vencimento,
cobranca_pagamento, cobranca_observacao,
cobranca_valor, cobranca_orcamento_id):
self.cobranca_banco = cobranca_banco
self.cobranca_vencimento = cobranca_vencimento
self.cobranca_pagamento = cobranca_pagamento
self.cobranca_observacao = cobranca_observacao
self.cobranca_valor = cobranca_valor
self.cobranca_orcamento_id = cobranca_orcamento_id
def deletar_cobranca(self):
banco.session.delete(self)
banco.session.commit()
class VeiculoModel(banco.Model):
__tablename__ = 'veiculos'
codigo = banco.Column(banco.Integer, primary_key=True)
tipo_veiculo = banco.Column(banco.String(80))
rotas = banco.relationship('RotaModel')
def __init__(self, codigo, tipo_veiculo):
self.codigo = codigo
self.tipo_veiculo = tipo_veiculo
def json(self):
return {
'codigo' : self.codigo,
'tipo_veiculo' : self.tipo_veiculo,
'rotas': [rota.json() for rota in self.rotas]
}
@classmethod
def find_veiculo(cls, codigo):
veiculo = cls.query.filter_by(codigo=codigo).first()
if veiculo:
return veiculo
return None
def save_veiculo(self):
banco.session.add(self)
banco.session.commit()
def update_veiculo(self, codigo, tipo_veiculo):
self.codigo = codigo
self.tipo_veiculo = tipo_veiculo
def delete_veiculo(self):
banco.session.delete(self)
banco.session.commit()
class SitelModel(banco.Model):
__tablename__ = 'sites'
site_id = banco.Column(banco.Integer, primary_key=True)
url = banco.Column(banco.String(80))
hoteis = banco.relationship('HotelModel')
def __init__(self, url):
self.url = url
def json(self):
return {'site_id': self.site_id, '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
@classmethod
def find_by_id(cls, site_id):
site = cls.query.filter_by(site_id=site_id).first()
if site:
return site
return None
def save_site(self):
banco.session.add(self)
banco.session.commit()
def delete_site(self):
[hotel.delete_hotel() for hotel in self.hoteis]
banco.session.delete(self)
banco.session.commit()
class AccountModel(banco.Model):
__tablename__ = 'account'
account_id = banco.Column(banco.Integer, primary_key=True)
name = banco.Column(banco.String(40), nullable=False)
initial_balance = banco.Column(banco.Float, default=0)
credits = banco.relationship('CreditModel')
debits = banco.relationship('DebitModel')
def __init__(self, name, initial_balance):
self.name = name
self.initial_balance = initial_balance
def json(self):
return {
"account_number": self.account_id,
"name": self.name,
"initial_balance": self.initial_balance,
}
@classmethod
def find(cls, account_id):
return cls.query.filter_by(account_id=account_id).first()
@classmethod
def find_all(cls, limit=50, offset=0):
return cls.query.limit(limit).offset(offset).all()
def save(self):
banco.session.add(self)
banco.session.commit()
class SiteModel(banco.Model):
__tablename__ = "sites"
#tabela com string
site_id = banco.Column(banco.Integer, primary_key=True)
url = banco.Column(banco.String(80))
hoteis = banco.relationship('HotelModel')
#
def __init__(self, url):
self.url = url
#retorna um json
def json(self):
return{
'site_id':self.site_id,
'url':self.url,
'hoteis':[hotel.json() for hotel in self.hoteis] #lista de hoteis lincados a este site]
}
# buscar por url
@classmethod
def find_site(cls, url):
site = cls.query.filter_by(url=url).first() #select * from w
if site:
return site
return None
def save_site(self):
banco.session.add(self)
banco.session.commit()
def delete_site(self):
banco.session.delete(self)
banco.session.commit()
class SiteModel(banco.Model):
__tablename__ = 'sites'
site_id = banco.Column(banco.Integer, primary_key=True)
nome = banco.Column(banco.String(40))
url = banco.Column(banco.String(80))
# Lista de objetos hoteis que possuem o site_id como chave secundaria
hoteis = banco.relationship('HotelModel')
def __init__(self, nome, url):
self.nome = nome
self.url = url
def json(self):
return {
"site_id": self.site_id,
"nome": self.nome,
"url": self.url,
"hoteis": [hotel.json() for hotel in self.hoteis]
}
@classmethod
def find_site_by_name(cls, nome):
site = cls.query.filter_by(nome=nome).first()
if site:
return site
else:
return None
@classmethod
def find_site_by_id(cls, site_id):
site = cls.query.filter_by(site_id=site_id).first()
if site:
return site
else:
return None
def save_site(self):
banco.session.add(self)
banco.session.commit()
def delete_site(self):
# Deletando todos os hoteis associados ao site (Relação de composição)
for hotel in self.hoteis:
hotel.delete_hotel()
# Deletando site
banco.session.delete(self)
banco.session.commit()
class HotelModel(banco.Model):
__tablename__ = 'hoteis'
hotel_id = banco.Column(banco.Integer, primary_key=True)
nome = banco.Column(banco.String(80))
estrelas = banco.Column(banco.Float(precision=1))
diaria = banco.Column(banco.Float(precision=2))
cidade = banco.Column(banco.String(40))
site_id = banco.Column(banco.Integer, banco.ForeignKey('sites.site_id'))
def __init__(self, hotel_id, nome, estrelas, diaria, cidade, site_id):
self.hotel_id = hotel_id
self.nome = nome
self.estrelas = estrelas
self.diaria = diaria
self.cidade = cidade
self.site_id = site_id
@classmethod
def encontrar_hotel(cls, hotel_id):
hotel = cls.query.filter_by(hotel_id=hotel_id).first()
if hotel:
return hotel
return None
def salvar_hotel(self):
banco.session.add(self)
banco.session.commit()
def atualizar_hotel(self, nome, estrelas, diaria, cidade):
self.nome = nome
self.estrelas = estrelas
self.diaria = diaria
self.cidade = cidade
def remover_hotel(self):
banco.session.delete(self)
banco.session.commit()
def json(self):
return {
'hotel_id': self.hotel_id,
'nome': self.nome,
'estrelas': self.estrelas,
'diaria': self.diaria,
'cidade': self.cidade,
'site_id': self.site_id,
}