class AcessModel(database.Model):
__tablename__ = 'acess'
acess_id = database.Column(database.Integer,
primary_key=True,
autoincrement=True)
date = database.Column(database.DateTime, default=datetime.datetime.now())
userId = database.Column(database.String,
database.ForeignKey('users.userId'))
nomeVend = database.Column(database.String, nullable=False)
acessMethod = database.Column(database.String)
def __init__(self, userId, acessMethod):
user = UserModel.findUser(userId)
if user:
self.userId = user.userId
self.nomeVend = user.nomeVend
else:
self.userId = userId
self.nomeVend = ''
self.date = datetime.datetime.now()
self.acessMethod = acessMethod
def saveAcess(self):
database.session.add(self)
database.session.commit()
class ParentModel(database.Model):
__tablename__ = "parent"
id = database.Column(database.Integer, primary_key=True)
name = database.Column(database.String(128))
children = database.Column(database.String(256))
createdAt = database.Column(database.DateTime, nullable=False, default=datetime.utcnow)
updatedAt = database.Column(database.DateTime, onupdate=datetime.utcnow)
def __init__(self, name, children):
self.name = name
self.children = children
def json(self):
return {
'id': self.id,
'name': self.name,
'children': self.children,
'createdAt': str(self.createdAt),
'updatedAt': str(self.updatedAt)
}
@classmethod
def find_parent(cls, id):
parent = cls.query.filter_by(id=id).first()
if parent:
return parent
return None
@classmethod
def parents(cls):
parents = cls.query.all()
if parents:
return parents
return None
def update_parent(self, data):
if data.name:
self.name = data.name
if data.children:
self.children = data.children
database.session.commit()
def save_parent(self):
database.session.add(self)
database.session.commit()
def delete_parent(self):
database.session.delete(self)
database.session.commit()
class ChildModel(database.Model):
__tablename__ = "child"
id = database.Column(database.Integer, primary_key=True)
name = database.Column(database.String(128))
parents = database.Column(database.String(256))
createdAt = database.Column(database.DateTime, nullable=False, default=datetime.utcnow)
updatedAt = database.Column(database.DateTime, onupdate=datetime.utcnow)
def __init__(self, name, parents):
self.name = name
self.parents = parents
def json(self):
return {
'id': self.id,
'name': self.name,
'parents': self.parents,
'createdAt': str(self.createdAt),
'updatedAt': str(self.updatedAt)
}
@classmethod
def find_child(cls, id):
child = cls.query.filter_by(id=id).first()
if child:
return child
return None
@classmethod
def childs(cls):
childs = cls.query.all()
if childs:
return childs
return None
def update_child(self, data):
if data.name:
self.name = data.name
if data.parents:
self.parents = data.parents
database.session.commit()
def save_child(self):
database.session.add(self)
database.session.commit()
def delete_child(self):
database.session.delete(self)
database.session.commit()
class UserModel(database.Model):
__tablename__ = 'users'
id = database.Column(database.Integer, primary_key=True, unique=True, nullable=False)
login = database.Column(database.String(40), nullable=False, unique=True)
password = database.Column(database.String(40), nullable=False)
city = database.Column(database.String(50))
def __init__(self, login, password, city):
self.login = login
self.password = password
self.city = city
def json(self):
return {
'id': self.id,
'login': self.login,
'city': self.city
}
def save_user(self):
database.session.add(self)
database.session.commit()
def update_user_login(self, login):
self.login = login
def update_user_password(self, password):
self.password = password
def update_user_city(self, city):
self.city = city
@classmethod
def find_user(cls, id):
user = cls.query.filter_by(id=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 delete_user(self):
database.session.delete(self)
database.session.commit()
class HotelModel(database.Model):
__tablename__ = "hotels"
hotel_id = database.Column(database.String, primary_key=True)
title = database.Column(database.String(80))
rate = database.Column(database.Float(precision=1))
price = database.Column(database.Float(precision=2))
city = database.Column(database.String(40))
def __init__(self, hotel_id, title, rate, price, city):
self.hotel_id = hotel_id
self.title = title
self.rate = rate
self.price = price
self.city = city
def json(self):
return {
"hotel_id": self.hotel_id,
"title": self.title,
"rate": self.rate,
"price": self.price,
"city": self.city,
}
@classmethod
def find_hotel(cls, hotel_id):
hotel = cls.query.filter_by(hotel_id=hotel_id).first()
if hotel:
return hotel
return None
def save_hotel(self):
database.session.add(self)
database.session.commit()
def update_hotel(self, title, rate, price, city):
self.title = title
self.rate = rate
self.price = price
self.city = city
def delete_hotel(self):
database.session.delete(self)
database.session.commit()
class ContactsModel(database.Model):
__tablename__ = 'contacts'
contact_id = database.Column(database.Integer, primary_key=True)
name = database.Column(database.String(80))
channel = database.Column(database.String(80))
value = database.Column(database.String(80))
obs = database.Column(database.String(80))
def __init__(self, contact_id, name, channel, value, obs):
self.contact_id = contact_id
self.name = name
self.channel = channel
self.value = value
self.obs = obs
def parse_json(self):
return {
'contact_id': self.contact_id,
'name': self.name,
'channel': self.channel,
'value': self.value,
'obs': self.obs
}
@classmethod
def find_contact(cls, contact_id):
contact = cls.query.filter_by(contact_id=contact_id).first()
if contact:
return contact
return None
def save_contact(self):
database.session.add(self)
database.session.commit()
def update_contact(self, name, channel, value, obs):
self.name = name
self.channel = channel
self.value = value
self.obs = obs
def delete_contact(self):
database.session.delete(self)
database.session.commit()
class SiteModel(database.Model):
__tablename__ = 'sites'
id = database.Column(database.Integer, primary_key=True)
url = database.Column(database.String(80))
hotels = database.relationship('HotelModel')
def __init__(self, url):
self.url = url
def json(self):
return {
'id': self.id,
'url': self.url,
'hotels': [hotel.json() for hotel in self.hotels]
}
@classmethod
def findById(cls, id):
site = cls.query.filter_by(id=id).first()
if site:
return site
return None
@classmethod
def findExists(cls, id):
site = SiteModel.findById(id)
if site:
return site
raise BadRequest('The informed site does not exist.')
def save(self):
database.session.add(self)
database.session.commit()
def delete(self):
[hotel.delete() for hotel in self.hotels]
database.session.delete(self)
database.session.commit()
class UserModel(database.Model):
__tablename__ = "users"
user_id = database.Column(database.Integer, primary_key=True)
login = database.Column(database.String(40))
password = database.Column(database.String(40))
def __init__(self, login, password):
self.login = login
self.password = password
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):
database.session.add(self)
database.session.commit()
def delete_user(self):
database.session.delete(self)
database.session.commit()
class PhilosopherModel(database.Model):
__tablename__ = 'philosophers'
id = database.Column(database.Integer, primary_key=True)
name = database.Column(database.String(50))
reviews = database.Column(database.Float(precision=2))
def __init__(self, id, name, reviews):
self.id = id
self.name = name
self.reviews = reviews
def json(self):
return {
'id': self.id,
'name': self.name,
'reviews': self.reviews
}
@classmethod
def find_philosopher(cls, id):
philosopher = cls.query.filter_by(id=id).first()
if philosopher:
return philosopher
return None
def save_philosopher(self):
database.session.add(self)
database.session.commit()
def update_philosopher(self, name, reviews):
self.name = name
self.reviews = reviews
def delete_philosopher(self):
database.session.delete(self)
database.session.commit()
class UserModel(database.Model):
__tablename__ = "user"
user_id = database.Column(database.Integer, primary_key=True)
username = database.Column(database.String(128), unique=True)
password = database.Column(database.String(128))
email = database.Column(database.String(128), nullable=False)
createdAt = database.Column(database.DateTime,
nullable=False,
default=datetime.utcnow)
updatedAt = database.Column(database.DateTime, onupdate=datetime.utcnow)
def __init__(self, username, password, email):
self.username = username
self.password = password
self.email = email
def json(self):
return {
'user_id': self.user_id,
'username': self.username,
'password': self.password,
'email': self.email,
'createdAt': str(self.createdAt),
'updatedAt': str(self.updatedAt)
}
@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 users(cls):
users = cls.query.all()
if users:
return users
return None
@classmethod
def find_by_username(cls, username):
user = cls.query.filter_by(username=username).first()
if user:
return user
return None
def update_user(self, data):
if data.username:
self.username = data.username
if data.password:
self.password = data.password
if data.email:
self.email = data.email
database.session.commit()
def save_user(self):
database.session.add(self)
database.session.commit()
def delete_user(self):
database.session.delete(self)
database.session.commit()
class UserModel(database.Model):
__tablename__ = 'users'
id = database.Column(database.Integer, primary_key=True, nullable=False)
fullname = database.Column(database.String(100), nullable=False)
email = database.Column(database.String(100), nullable=False, unique=True)
login = database.Column(database.String(100), nullable=False, unique=True)
password = database.Column(database.String(100), nullable=False)
activated = database.Column(database.Boolean, default=False)
def __init__(self, fullname, email, login, password, activated):
self.fullname = fullname
self.email = email
self.login = login
self.password = password
self.activated = activated
def json(self):
return {
'id': self.id,
'fullname': self.fullname,
'email': self.email,
'login': self.login,
'activated': self.activated
}
@classmethod
def findById(cls, id):
user = cls.query.filter_by(id=id).first()
if user:
return user
return None
@classmethod
def findByLogin(cls, login):
user = cls.query.filter_by(login=login).first()
if user:
return user
return None
@classmethod
def findByEmail(cls, email):
user = cls.query.filter_by(email=email).first()
if user:
return user
return None
@classmethod
def findExists(cls, id):
user = UserModel.findById(id)
if user:
return user
raise BadRequest('The informed user does not exist.')
def send_confirmation_email(self):
registration_link = request.url_root[:-1] + url_for('userconfirm', id=self.id)
post('https://api.mailgun.net/v3/{}/messages'.format(MAILGUN_DOMAIN),
auth=('api', MAILGUN_API_KEY),
data={'from': '{} <{}>'.format(FROM_TITLE, FROM_EMAIL),
'to': self.email,
'subject': 'Confirmação de Cadastro',
'text': 'Confirme seu cadastro clicando no link a seguir: {}'.format(registration_link),
'html': render_template('user_confirm.html', registration_link=registration_link)
}
)
def save(self):
database.session.add(self)
database.session.commit()
def update(self, fullname, login, password):
self.fullname = fullname
self.login = login
self.password = password
def delete(self):
database.session.delete(self)
database.session.commit()
class TargetModel(database.Model):
__tablename__ = 'targets'
target_id = database.Column(database.String, primary_key=True)
target_key = database.Column(database.String(16))
target_ip = database.Column(database.String(15))
target_hostname = database.Column(database.String(80))
target_city = database.Column(database.String(80))
target_region = database.Column(database.String(80))
target_country = database.Column(database.String(80))
target_location = database.Column(database.String(80))
target_organization = database.Column(database.String(80))
target_postal = database.Column(database.String(20))
target_timezone = database.Column(database.String(20))
def __init__(self, target_id, target_key, target_ip, target_hostname,
target_city, target_region, target_country, target_location,
target_organization, target_postal, target_timezone):
self.target_id = target_id
self.target_key = target_key
self.target_ip = target_ip
self.target_hostname = target_hostname
self.target_city = target_city
self.target_region = target_region
self.target_country = target_country
self.target_location = target_location
self.target_organization = target_organization
self.target_postal = target_postal
self.target_timezone = target_timezone
def json(self):
return {
'target_id': self.target_id,
'target_key': self.target_key,
'target_ip': self.target_ip,
'target_hostname': self.target_hostname,
'target_city': self.target_city,
'target_region': self.target_region,
'target_country': self.target_country,
'target_location': self.target_location,
'target_organization': self.target_organization,
'target_postal': self.target_postal,
'target_timezone': self.target_timezone
}
@classmethod
def find_target(cls, target_id):
target = cls.query.filter_by(target_id=target_id).first()
if target:
return target
return None
def save_target(self):
database.session.add(self)
database.session.commit()
class ProductModel(database.Model):
__tablename__ = 'products'
codigo = database.Column(database.Integer, primary_key=True)
nome = database.Column(database.String(80))
preco = database.Column(database.Float(precision=2))
preco_prime = database.Column(database.Float(precision=1))
preco_antigo = database.Column(database.Float(precision=1))
disponibilidade = database.Column(database.Boolean)
preco_desconto = database.Column(database.Float(precision=1))
preco_desconto_prime = database.Column(database.Float(precision=1))
link_descricao = database.Column(database.String(200))
foto = database.Column(database.String(200))
produto_prime = database.Column(database.Boolean)
def __init__(self, codigo=None, nome=None, preco=None, preco_prime=None, preco_antigo=None, disponibilidade=False,
preco_desconto=None, preco_desconto_prime=None, link_descricao=None, foto=None, produto_prime=False):
self.codigo = codigo
self.nome = nome
self.preco = preco
self.preco_prime = preco_prime
self.preco_antigo = preco_antigo
self.disponibilidade = disponibilidade
self.preco_desconto = preco_desconto
self.preco_desconto_prime = preco_desconto_prime
self.link_descricao = link_descricao
self.foto = foto
self.produto_prime = produto_prime
def json(self):
return {
'codigo': self.codigo,
'nome': self.nome,
'preco': self.preco,
'preco_prime': self.preco_prime,
'preco_antigo': self.preco_antigo,
'disponibilidade': self.disponibilidade,
'preco_desconto': self.preco_desconto,
'preco_desconto_prime': self.preco_desconto_prime,
'link_descricao': self.link_descricao,
'foto': self.foto,
'produto_prime': self.produto_prime
}
@classmethod
def find_product(cls, codigo):
product = cls.query.filter_by(codigo=codigo).first()
if product:
return product
return None
def save_product(self):
database.session.add(self)
database.session.commit()
def update_product(self, nome=None, preco=None, preco_prime=None, preco_antigo=None, disponibilidade=False,
preco_desconto=None, preco_desconto_prime=None, link_descricao=None, foto=None, produto_prime=False):
self.nome = nome
self.preco = preco
self.preco_prime = preco_prime
self.preco_antigo = preco_antigo
self.disponibilidade = disponibilidade
self.preco_desconto = preco_desconto
self.preco_desconto_prime = preco_desconto_prime
self.link_descricao = link_descricao
self.foto = foto
self.produto_prime = produto_prime
def delete_product(self):
database.session.delete(self)
database.session.commit()
class UserModel(database.Model):
__tablename__ = 'users'
userId = database.Column(database.String, primary_key=True)
profileName = database.Column(database.String(80), nullable=False)
platform = database.Column(database.String, nullable=False)
phoneModel = database.Column(database.String, nullable=False)
codvend = database.Column(database.String, nullable=False)
nomeVend = database.Column(database.String, nullable=False)
salary = database.Column(database.Float(precision=2))
comissionObjective = database.Column(database.Float(precision=2))
comissionMult = database.Column(database.Float(precision=1), default=1.0)
flagAdmin = database.Column(database.Boolean, default=False)
flagHaveAcess = database.Column(database.Boolean, default=False)
insertDate = database.Column(database.DateTime,
default=datetime.datetime.now())
startedDate = database.Column(database.Date)
def __init__(self, userId, profileName, platform, phoneModel, codvend,
nomeVend):
self.userId = userId
self.profileName = profileName
self.platform = platform
self.phoneModel = phoneModel
self.codvend = codvend
self.nomeVend = nomeVend
@classmethod
def findUser(cls, userId):
user = cls.query.filter_by(userId=userId).first()
if user:
return user
return None
def saveUser(self):
database.session.add(self)
database.session.commit()
class HotelModel(database.Model):
__tablename__ = 'hotels'
id = database.Column(database.Integer, primary_key=True, nullable=False)
name = database.Column(database.String(100), nullable=False)
classification = database.Column(database.Float(precision=1),
nullable=False)
cep = database.Column(database.String(20), nullable=False)
address = database.Column(database.String(100), nullable=False)
neighborhood = database.Column(database.String(100), nullable=False)
city = database.Column(database.String(100), nullable=False)
state = database.Column(database.String(100), nullable=False)
id_site = database.Column(database.Integer,
database.ForeignKey('sites.id'))
def __init__(self, name, classification, cep, address, neighborhood, city,
state, id_site):
self.name = name
self.classification = classification
self.cep = cep
self.address = address
self.neighborhood = neighborhood
self.city = city
self.state = state
self.id_site = id_site
def json(self):
return {
'id': self.id,
'name': self.name,
'classification': self.classification,
'cep': self.cep,
'address': self.address,
'neighborhood': self.neighborhood,
'city': self.city,
'state': self.state,
'id_site': self.id_site
}
@classmethod
def findById(cls, id):
hotel = cls.query.filter_by(id=id).first()
if hotel:
return hotel
return None
@classmethod
def findExists(cls, id):
hotel = HotelModel.findById(id)
if hotel:
return hotel
raise BadRequest('The informed hotel does not exist.')
def save(self):
database.session.add(self)
database.session.commit()
def update(self, name, classification, cep, address, neighborhood, city,
state):
self.name = name
self.classification = classification
self.cep = cep
self.address = address
self.neighborhood = neighborhood
self.city = city
self.state = state
def delete(self):
database.session.delete(self)
database.session.commit()
