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 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 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 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 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 CreditModel(banco.Model):
__tablename__ = 'credit'
credit_id = banco.Column(banco.Integer, primary_key=True)
value = banco.Column(banco.Float, nullable=False)
description = banco.Column(banco.String, nullable=False)
account_id = banco.Column(banco.Integer,
banco.ForeignKey('account.account_id'))
def __init__(self, account_id, value, description):
self.account_id = account_id
self.value = value
self.description = description
def json(self):
return {
"credit_id": self.credit_id,
"account_number": self.account_id,
"value": self.value,
"description": self.description,
}
@classmethod
def find_credits(cls, account_id, limit=50, offset=0):
return cls.query.filter_by(
account_id=account_id).limit(limit).offset(offset)
@classmethod
def find_all_credits(cls, account_id):
return cls.query.filter_by(account_id=account_id)
def save(self):
banco.session.add(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 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):
__tablename__ = 'hoteisf'
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))
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
#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
}
@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 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 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 EstudanteModel(banco.Model):
__tablename__ = 'estudantes'
estudante_id = banco.Column(banco.Integer, primary_key=True)
nome = banco.Column(banco.String)
idade = banco.Column(banco.Integer)
sexo = banco.Column(banco.String)
ano_letivo = banco.Column(banco.String)
def __init__(self, estudante_id, nome, idade, sexo, ano_letivo):
self.estudante_id = estudante_id
self.nome = nome
self.idade = idade
self.sexo = sexo
self.ano_letivo = ano_letivo
def json(self):
return {
'estudante_id': self.estudante_id,
'nome': self.nome,
'idade': self.idade,
'sexo': self.sexo,
'ano_letivo': self.ano_letivo
}
# metodo de classe
@classmethod
def find_estudante(cls, estudante_id):
# select * from estudantes where estudante_id = {estudante_id} limit 1
estudante = cls.query.filter_by(estudante_id=estudante_id).first()
if estudante:
return estudante
return None
def save_estudante(self):
# insert into estudantes (colunas) values (campos)
# adiciona o proprio objeto
banco.session.add(self)
banco.session.commit()
def update_estudante(self, nome, idade, sexo, ano_letivo):
# update estudantes set campo = campo where id_estudante = id_estudante
self.nome = nome
self.idade = idade
self.sexo = sexo
self.ano_letivo = ano_letivo
def delete_hotel(self):
# delete from estudante where id_estudante = id_estudante
# deletando o proprio objeto
banco.session.delete(self)
banco.session.commit()
class TaskModel(banco.Model):
__tablename__ = 'tasks'
task_id = banco.Column(banco.String, primary_key=True)
nome = banco.Column(banco.String(80))
descricao = banco.Column(banco.String(80))
tipo = banco.Column(banco.String(80))
dia = banco.Column(banco.String(40))
hora = banco.Column(banco.String(40))
local = banco.Column(banco.String(40))
participante = banco.Column(banco.String(40))
def __init__(self, task_id, nome, descricao, tipo, dia, hora, local,
participante):
self.task_id = task_id
self.nome = nome
self.descricao = descricao
self.tipo = tipo
self.dia = dia
self.hora = hora
self.local = local
self.participante = participante
def json(self):
return {
'task_id': self.task_id,
'nome': self.nome,
'descricao': self.descricao,
'tipo': self.tipo,
'dia': self.dia,
'hora': self.hora,
'local': self.local,
'participante': self.participante
}
@classmethod
def find_task(cls, task_id):
task = cls.query.filter_by(task_id=task_id).first(
) # Select * From tasks Where task_id = $task_if
if task:
return task
return None
def save_task(self):
banco.session.add(self)
banco.session.commit()
def update_task(self, nome, descricao, tipo, dia, hora, local,
participante):
self.nome = nome
self.descricao = descricao
self.tipo = tipo
self.dia = dia
self.hora = hora
self.local = local
self.participante = participante
def delete_task(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 SiteModel(banco.Model):
__tablename__ = 'TB_SITES'
id = banco.Column(banco.Integer, primary_key=True)
url = banco.Column(banco.String(50))
hoteis = banco.relationship('HotelModel')
def __init__(self, url):
self.url = url
def convertToDictionary(self):
return {
'id': self.id,
'nota': self.url,
'hoteis': [hotel.convertToDictionary() for hotel in self.hoteis]
}
@classmethod
def find_all(cls):
sites = cls.query.all()
if sites:
return sites
return None
@classmethod
def find_by_id(cls, id):
site = cls.query.filter_by(id=id).first()
if site:
return site
return None
@classmethod
def find_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.hoteis()]
banco.session.delete(self)
banco.session.commit()
def update_site(self, url):
self.url = url
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 BlocklistModel(banco.Model):
__tablename__ = 'blocklist'
id = banco.Column(banco.Integer, primary_key=True, autoincrement=True)
jti = banco.Column(banco.String(36), nullable=False)
created_at = banco.Column(banco.DateTime, nullable=False)
def blocklist_add(jti, now):
banco.session.add(BlocklistModel(jti=jti, created_at=now))
banco.session.commit()
return True
@classmethod
def token_filter(cls, jti):
token = banco.session.query(cls.id).filter_by(jti=jti).scalar()
return token
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 SiteModel(banco.Model):
__tablename__ = 'sites'
site_id = banco.Column(banco.Integer, primary_key=True)
url = banco.Column(banco.String(80))
hoteis = banco.relationship('HotelModel')
# Cria os campos do modelo da classe hotel >>Isso é um objeto<<
def __init__(self, url):
self.url = url
# Funcão que Transforma um objeto em um fomato DICIONÁRIO que converte/ou é um JSON - automaticamente >>> <<<
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):
url = cls.query.filter_by(url=url).first()
if url:
return url
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 update_site(self, url):
self.url = url
def delete_site(self):
# Deletando todos os hoteis associado ao site
[hotel.delete_hotel() for hotel in self.hoteis]
# Agora deleta o site
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))
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,
"cidade": self.cidade,
"diaria": self.diaria
}
#cls = HotelModel
@classmethod
def find_hotel(cls, hotel_id):
hotel = cls.query.filter_by(hotel_id=hotel_id).first()
#SELEC * FROM hoteis WHERE hotel_id = $hotel_id LIMIT 1
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__ = 'users'
id = banco.Column(banco.Integer, primary_key=True)
name = banco.Column(banco.String)
email = banco.Column(banco.String)
password = banco.Column(banco.String)
def __init__(self, name, email, password):
self.name = name
self.email = email
self.password = password
self.admin = 0
def json(self):
return {
'id' : self.id,
'name' : self.name,
'email' : self.email
}
@classmethod
def find_user(cls, id):
user = cls.query.filter_by(id=id).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(self):
banco.session.add(self)
banco.session.commit()
def update(self, name, email, password):
self.name = name
self.email = email
self.password = password
def delete(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 SiteModel(banco.Model):
__tablename__ = 'sites'
site_id = banco.Column(banco.Integer, primary_key=True)
url = banco.Column(banco.String(80))
hoteis = banco.relationship(
'HotelModel') #relacionamento entre as classe do banco
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() #SELECT * FROM Hoteis WHERE id=id LIMIT 1
if site:
return site
return None
@classmethod
def find_by_id(cls, site_id):
site = cls.query.filter_by(
site_id=site_id).first() #SELECT * FROM Hoteis WHERE id=id LIMIT 1
if site:
return site
return None
def save_site(self):
banco.session.add(self)
banco.session.commit()
def delete_site(self):
#deletando todos os hoteis relacionados ao site
[hotel.delete_hotel() for hotel in self.hoteis]
#deletando o site
banco.session.delete(self)
banco.session.commit()
class SiteModel(banco.Model):
__tablename__ = 'sites'
site_id = banco.Column(banco.Integer, primary_key=True)
url = banco.Column(banco.String(80))
# criando uma relação entre as tabelas
hoteis = banco.relationship('HotelModel') # lista de objs hoteis
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
] # self.hoteis -> esta dentro do self recebido do obj
}
@classmethod
def find_site(cls, url):
site = cls.query.filter_by(
url=url).first() # SELECT * FROM hoteis WHERE hotel_id = hotel_id
if site:
return site
return None
@classmethod
def find_by_id(cls, site_id):
site = cls.query.filter_by(site_id=site_id).first(
) # SELECT * FROM hoteis WHERE hotel_id = hotel_id
if site:
return site
return None
def save_site(self):
# adiciona o obj no banco
banco.session.add(self)
banco.session.commit()
def delete_site(self):
# deletando todos hoteis associados ao site
[hotel.delete_hotel() for hotel in self.hoteis]
# deletando site
banco.session.delete(self)
banco.session.commit()
class PointModel(banco.Model):
__tablename__ = 'points'
id = banco.Column(banco.Integer, primary_key=True)
date = banco.Column(banco.String)
hour = banco.Column(banco.String)
employee_id = banco.Column(banco.ForeignKey('employees.id'))
def __init__(self, date, hour, employee_id):
self.date = date
self.hour = hour
self.employee_id = employee_id
def json(self):
return {
'id': self.id,
'date': self.date,
'hour': self.hour,
'employee_id': self.employee_id
}
@classmethod
def find_point(cls, id):
point = cls.query.filter_by(id=id).first()
if point:
return point
return None
@classmethod
def find_day(cls, date):
points = cls.query.filter_by(date=date)
if points:
return points
return None
def save(self):
banco.session.add(self)
banco.session.commit()
def update(self, date, hour):
self.date = date
self.hour = hour
def delete(self):
banco.session.delete(self)
banco.session.commit()
class UsuarioModel(banco.Model):
__tablename__ = 'usuarios'
cpf = banco.Column(banco.Integer, primary_key=True)
nome = banco.Column(banco.String(80))
sobrenome = banco.Column(banco.String(80))
email = banco.Column(banco.String(80))
nascimento = banco.Column(banco.String(80))
def __init__(self, cpf, nome, sobrenome, email, nascimento):
self.cpf = cpf
self.nome = nome
self.sobrenome = sobrenome
self.email = email
self. nascimento = nascimento
def json(self):
return {
'cpf':self.cpf,
'nome': self.nome,
'sobrenome': self.sobrenome,
'email': self.email,
'nascimento': self.nascimento,
}
@classmethod
def find_usuario(cls, cpf):
usuario = cls.query.filter_by(cpf=cpf).first()
if usuario:
return usuario
return None
def save_usuario(self):
banco.session.add(self)
banco.session.commit()
def update_usuario(self, nome, sobrenome, email, nascimento):
self.nome = nome
self.sobrenome = sobrenome
self.email = email
self.nascimento = nascimento
def delete_usuario(self):
banco.session.delete(self)
banco.session.commit()
class CaminhoneiroModel(banco.Model):
__tablename__ = 'caminhoneiros'
caminhoneiro_id = banco.Column(banco.Integer, primary_key=True)
nome = banco.Column(banco.String(80))
idade = banco.Column(banco.String(3))
sexo = banco.Column(banco.String(10))
possui_veiculo = banco.Column(banco.String(3))
tipo_CNH = banco.Column(banco.String(80))
carregado = banco.Column(banco.String(3))
tipo_veiculo = banco.Column(banco.String(80))
def __init__(self, nome, idade, sexo, possui_veiculo, tipo_CNH, carregado, tipo_veiculo):
self.nome = nome
self.idade = idade
self.sexo = sexo
self.possui_veiculo = possui_veiculo
self.tipo_CNH = tipo_CNH
self.carregado = carregado
self.tipo_veiculo = tipo_veiculo
def json(self):
return {
'caminhoneiro_id' : self.caminhoneiro_id,
'nome' : self.nome,
'idade' : self.idade,
'sexo' : self.sexo,
'possui_veiculo' : self.possui_veiculo,
'tipo_CNH' : self.tipo_CNH,
'carregado' : self.carregado,
'tipo_veiculo' : self.tipo_veiculo
}
@classmethod
def find_caminhoneiro(cls, caminhoneiro_id):
caminhoneiro = cls.query.filter_by(caminhoneiro_id=caminhoneiro_id).first()
if caminhoneiro:
return caminhoneiro
return None
def save_caminhoneiro(self):
banco.session.add(self)
banco.session.commit()
def update_caminhoneiro(self, nome, idade, sexo, possui_veiculo, tipo_CNH, carregado, tipo_veiculo):
self.nome = nome
self.idade = idade
self.sexo = sexo
self.possui_veiculo = possui_veiculo
self.tipo_CNH = tipo_CNH
self.carregado = carregado
self.tipo_veiculo = tipo_veiculo
def delete_caminhoneiro(self):
banco.session.delete(self)
banco.session.commit()