Esempio n. 1
0
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
        }
Esempio n. 2
0
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
Esempio n. 3
0
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()
Esempio n. 4
0
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()
Esempio n. 5
0
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()
Esempio n. 6
0
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()
Esempio n. 8
0
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()
Esempio n. 9
0
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()
Esempio n. 10
0
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()
Esempio n. 11
0
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()
Esempio n. 12
0
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
Esempio n. 13
0
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()
Esempio n. 14
0
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()
Esempio n. 15
0
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()
Esempio n. 16
0
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()
Esempio n. 17
0
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()
Esempio n. 18
0
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()
Esempio n. 19
0
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()
Esempio n. 20
0
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()
Esempio n. 21
0
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()
Esempio n. 22
0
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()
Esempio n. 24
0
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()
Esempio n. 25
0
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()
Esempio n. 26
0
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()
Esempio n. 27
0
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()
Esempio n. 28
0
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()
Esempio n. 29
0
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()
Esempio n. 30
0
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,
        }