class Admin(db.Model, basic_opt):
__tablename__ = "t_auth_admin"
uuid = db.Column(db.String(36), primary_key=True)
username = db.Column(db.String(128), nullable=False)
hash_password = db.Column(db.String(128), nullable=False)
login_type = db.Column(db.Boolean, default=False)
create_time = db.Column(db.DateTime, default=datetime.datetime.utcnow)
@property
def password(self):
raise AttributeError("password can't be read.")
@password.setter
def password(self, password):
self.hash_password = generate_password_hash(password)
def confirm_password(self, password):
return check_password_hash(self.hash_password, password)
@classmethod
def find_by_username(cls, username):
user = None
try:
user = cls.query.filter(cls.username == username).first()
except SQLAlchemyError as e:
return RetStatus(False, e.message)
return RetStatus(status=True, data=user)
@classmethod
def find_by_uuid(cls, uuid):
user = None
try:
user = cls.query.filter(cls.uuid == uuid).first()
except SQLAlchemyError as e:
return RetStatus(False, e.message)
return RetStatus(True, data=user)
class User(db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(120), nullable=False)
cashBalance = db.Column(db.Float, nullable=False)
purchaseHistory = db.relationship('PurchaseHistory',
backref='user',
lazy=True)
def __init__(self, name, cashBalance):
self.name = name
self.cashBalance = cashBalance
def insert(self):
db.session.add(self)
db.session.commit()
def update(self):
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
@classmethod
def get_by_name(cls, name):
return cls.query.filter_by(name=name).first()
@classmethod
def get_by_id(cls, id):
return cls.query.filter_by(id=id).first()
@classmethod
def get_all(cls):
return cls.query.all()
class SdAllDesa(db.Model):
__tablename__ = 'sd_all_desa'
__bind_key__ = 'sideka'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
region_code = db.Column(db.String(length=15), nullable=False)
region_name = db.Column(db.String(length=80), nullable=False)
parent_code = db.Column(db.String(length=15))
depth = db.Column(db.Integer)
class NodeMsg(db.Model, basic_opt):
uuid = db.Column(db.Integer, primary_key=True, autoincress=True)
title = db.Column(db.String(128), nullable=False)
msg = db.Column(db.String(256), nullable=False)
nodes = db.relationship('NodeTree',
secondary=node_m2m_msg,
lazy='dynamic',
backref=db.backref('msgs', lazy='joined'))
class Admin(db.Model, CRUD):
__tablename__ = "Admin"
uuid = db.Column(db.String(36), primary_key=True)
phone_number = db.Column(db.String(11), nullable=False)
hash_password = db.Column(db.String(128), nullable=False)
open_id = db.Column(db.String(30))
expire = db.Column(db.DateTime(), default=datetime.datetime.utcnow)
role = db.Column(db.Integer, default=False)
is_active = db.Column(db.Boolean, default=False)
c_time = db.Column(db.DateTime, default=datetime.datetime.utcnow)
l_time = db.Column(db.DateTime)
nodes = db.relationship('NodeTree', secondary=admin_m2m_node, lazy="dynamic", backref=db.backref('users', lazy='joined'))
@property
def password(self):
raise AttributeError('password cannot be read')
@password.setter
def password(self, password):
self.hash_password = generate_password_hash(password)
def confirm_password(self, password):
return check_password_hash(self.hash_password, password)
@classmethod
def find_by_phone_number(cls, phone_number):
return cls.query.filter(cls.phone_number==phone_number).first()
@classmethod
def find_by_uuid(cls, uuid):
return cls.query.filter(cls.uuid==uuid).first()
class EnderecoModel(db.Model):
__tablename__ = 'tb_endereco'
id = db.Column(db.Integer, primary_key=True)
logradouro = db.Column(db.String(255))
numero = db.Column(db.String(4))
complemento = db.Column(db.String(45))
estado = db.Column(db.String(45))
cep = db.Column(db.String(8))
ponto_referencia = db.Column(db.String(65))
fk_id_cidade = db.Column(db.Integer, db.ForeignKey('tb_cidade.id'), nullable=False)
cidade = db.relationship('CidadeModel', backref='cidade', primaryjoin="EnderecoModel.fk_id_cidade==CidadeModel.id", uselist=False)
fk_id_estado = db.Column(db.Integer, db.ForeignKey('tb_estado.id'), nullable=False)
estado = db.relationship('EstadoModel', backref='estado', primaryjoin="EnderecoModel.fk_id_estado==EstadoModel.id", uselist=False)
def __init__(self, logradouro, numero, complemento, cidade, estado, cep, ponto_referencia):
self.logradouro = logradouro
self.numero = numero
self.complemento = complemento
self.cidade = cidade
self.estado = estado
self.cep = cep
self.ponto_referencia = ponto_referencia
def __str__(self):
return '<Endereco %s>'%(self.logradouro)
class NaturezaModel(db.Model):
__tablename__ = 'tb_natureza'
id = db.Column(db.Integer, primary_key=True)
tipo = db.Column(db.String(255))
def __init__(self, tipo):
self.tipo = tipo
def __str__(self):
return '<Natureza %s>'%(self.tipo)
class CidadeModel(db.Model):
__tablename__ = 'tb_cidade'
id = db.Column(db.Integer, primary_key=True)
nome = db.Column(db.String(255))
def __init__(self, cidade):
self.cidade = cidade
def __str__(self):
return '<Cidade %s>' % (self.nome)
class EstadoModel(db.Model):
__tablename__ = 'tb_estado'
id = db.Column(db.Integer, primary_key=True)
nome = db.Column(db.String(255))
def __init__(self, nome):
self.nome = nome
def __str__(self):
return '<Estado %s>' % (self.nome)
class ImagemModel(db.Model):
__tablename__ = 'tb_imagem'
id = db.Column(db.Integer, primary_key=True)
nome = db.Column(db.String(255))
dt_insercao = db.Column(db.DateTime, default=func.current_timestamp())
def __init__(self, nome):
self.nome = nome
def __str__(self):
return '<Imagem %s>' % (self.nome)
class WpSiteMeta(db.Model):
__tablename__ = 'wp_sitemeta'
__bind_key__ = 'sideka'
meta_id = db.Column('meta_id',
db.Integer,
primary_key=True,
nullable=False)
site_id = db.Column('site_id', db.Integer, nullable=False)
meta_key = db.Column('meta_key', db.String(length=255))
meta_value = db.Column('meta_value', db.Text(length=None))
def __repr__(self):
return '<WpSiteMeta(%r, %r)>' % (self.meta_key, self.meta_value)
class SdSupradesa(db.Model):
__tablename__ = 'sd_supradesa'
__bind_key__ = 'sideka'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
region_code = db.Column(db.String(length=50), unique=True)
flag = db.Column(db.String(length=50))
name = db.Column(db.String(length=50))
blog_agregate = db.Column(db.String(length=50))
username = db.Column(db.String(length=50))
password = db.Column(db.String(length=50))
zoom = db.Column(db.Integer)
latitude = db.Column(db.Float)
longitude = db.Column(db.Float)
class Pessoa(db.Model):
__tablename__ = 'pessoas'
id = db.Column('id', db.Integer, primary_key=True, autoincrement=True)
nome = db.Column('nome', db.String(50))
email = db.Column('email', db.String(50))
def __init__(self, nome, email, id=None):
self.nome = nome
self.email = email
self.id = id
def __repr__(self):
return "<Pessoa [id = %s, nome = %s, email = %s]>" % (self.id, self.nome, self.email)
class ProdutoModel(db.Model):
__tablename__ = 'tb_produto'
id = db.Column(db.Integer, primary_key=True)
nome = db.Column(db.String(255))
descricao = db.Column(db.Text())
preco = db.Column(db.Float(precision='3,2'))
is_visivel = db.Column(db.Boolean, default=False)
is_deleted = db.Column(db.Boolean, default=False)
dt_insercao = db.Column(db.DateTime, default=func.current_timestamp())
fk_id_empresa = db.Column(db.Integer,
db.ForeignKey('tb_empresa.id'),
nullable=False)
empresa = db.relationship(
'EmpresaModel',
backref='empresa',
primaryjoin="ProdutoModel.fk_id_empresa==EmpresaModel.id",
uselist=False)
def __init__(self, nome, descricao, preco, is_visivel, is_deleted,
empresa):
self.nome = nome
self.descricao = descricao
self.preco = preco
self.is_visivel = is_visivel
self.is_deleted = is_deleted
self.empresa = empresa
def __str__(self):
return '<Produto %r>' % (self.nome)
class NodeInfo(db.Model, basic_opt):
uuid = db.Column(db.Integer, primary_key=True, autoincress=True)
age = db.Column(db.Integer)
sex = db.Column(db.Boolean, default=False)
campuse_id = db.Column(db.String(60), nullable=False)
nodes = db.relationship('NodeTree', secondary=node_m2m_info, lazy='dynamic', backref=db.backref('infos', lazy='joined'))
@classmethod
def find_by_uuid(cls, uuid):
ret = RetStatus(True)
try:
ret.data = cls.query.filter(cls.uuid == uuid).first()
except SQLAlchemyError as e:
return RetStatus(False, e.message)
return ret
class WpUserMeta(db.Model):
__tablename__ = 'wp_usermeta'
__bind_key__ = 'sideka'
umeta_id = db.Column('umeta_id',
db.Integer,
primary_key=True,
nullable=False)
meta_key = db.Column('meta_key', db.String(length=255))
meta_value = db.Column('meta_value', db.Text(length=None))
user_id = db.Column('user_id', db.Integer, db.ForeignKey('wp_users.ID'))
user = db.relationship('WpUser')
def __repr__(self):
return '<WpUserMeta(%r, %r)>' % (self.meta_key, self.meta_value)
class Book(db.Model):
__tablename__ = "book"
id = db.Column(db.Integer, primary_key=True)
bookStoreId = db.Column(db.Integer,
db.ForeignKey('book_store.id'),
nullable=False)
bookName = db.Column(db.String(200), nullable=False)
price = db.Column(db.Float, nullable=False)
def __init__(self, bookStoreId, bookName, price):
self.bookStoreId = bookStoreId
self.bookName = bookName
self.price = price
def insert(self):
db.session.add(self)
db.session.commit()
def update(self):
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
@classmethod
def get(cls, bookName):
return cls.query.filter_by(bookName=bookName).first()
@classmethod
def get_all(cls):
return cls.query.all()
@classmethod
def get_by_price(cls, price):
return cls.query.filter(cls.price <= price).order_by(
cls.price, cls.bookName).all()
@classmethod
def get_by_key_word(cls, key_word):
search = "%{}%".format(key_word)
return cls.query.filter(cls.bookName.like(search)).order_by(
cls.bookName).all()
@classmethod
def get_price_by_store_name_book_name(cls, store_name, book_name):
return db.session.query(cls.price).join(book_store.BookStore, cls.bookStoreId == book_store.BookStore.id). \
filter(book_store.BookStore.storeName == store_name, cls.bookName == book_name).first()
class ContatoModel(db.Model):
__tablename__ = 'tb_contato'
id = db.Column(db.Integer, primary_key=True)
nome = db.Column(db.String(255))
email = db.Column(db.String(255))
telefone = db.Column(db.String(13))
descricao = db.Column(db.Text())
def __init__(self, nome, email, telefone, descricao):
self.nome = nome
self.email = email
self.telefone = telefone
self.descricao = descricao
def __str__(self):
return '<Contato %r>' % (self.nome)
class Encoding(db.Model):
__tablename__ = 'encodings'
id = db.Column('id', db.Integer, primary_key=True, autoincrement=True)
medidas = db.Column('medidas', db.ARRAY(db.Float, 128))
pessoa_id = db.Column('pessoa_id', db.ForeignKey("pessoas.id"))
pessoa = db.relationship("Pessoa")
def __init__(self, pessoa_id, medidas, id=None):
self.pessoa_id = pessoa_id
self.medidas = medidas
self.id = id
def __repr__(self):
return "<Encoding [pessoa_id = %s, medidas = %s]>" % (self.pessoa_id,
self.medidas)
class MenuList(db.Model, TreeMixin):
__tablename__ = "MenuList"
name = db.Column(db.String(80), nullable=False)
sex = db.Column(db.Integer, default=0)
age = db.Column(db.Integer, default=0)
address = db.Column(db.String(120), default='')
identify_card = db.Column(db.String(20), default=0)
campus_id = db.Column(db.String(30), default='')
cantact = db.Column(db.String(20), default='')
class UsuarioModel(db.Model):
__tablename__ = 'tb_usuario'
id = db.Column(db.Integer, primary_key=True)
login = db.Column(db.String(40))
senha = db.Column(db.String(255))
def __init__(self, login, senha, id = None, token = None ):
self.login = login
self.set_senha(senha)
self.id = id
self.token = token
def set_senha(self, senha):
self.senha = generate_password_hash(senha)
def verificar_senha(self, value):
return check_password_hash(self.senha, value)
def generate_auth_token(self, expiration=None):
s = Serializer(secret_key, expires_in=expiration) # TimedJSONWebSignatureSerializer
dumps = s.dumps({'id': self.id})
self.token = dumps.decode('ascii')
return dumps
@staticmethod
def verify_auth_token(token):
current_app.logger.info("Token: %s" % (token))
s = Serializer(secret_key)
print(s)
try:
data = s.loads(token)
except SignatureExpired:
return None # valid token, but expired
except BadSignature:
return None # invalid token
user = UsuarioModel.query.get(data['id'])
return user
def __str__(self):
return '<Usuario %r>' % (self.login)
class PurchaseHistory(db.Model):
__tablename__ = 'puchase_history'
id = db.Column(db.Integer, primary_key=True)
userId = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
bookName = db.Column(db.String(200), nullable=False)
storeName = db.Column(db.String(200), nullable=False)
transactionAmount = db.Column(db.Float, nullable=False)
transactionDate = db.Column(db.String(200), nullable=False)
def __init__(self, userId, bookName, storeName, transactionAmount,
transactionDate):
self.userId = userId
self.bookName = bookName
self.storeName = storeName
self.transactionAmount = transactionAmount
self.transactionDate = transactionDate
def insert(self):
db.session.add(self)
db.session.commit()
def update(self):
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
@classmethod
def get_by_user_id(cls, userId):
return cls.query.filter_by(userId=userId).all()
@classmethod
def get_most_popular_store_name(cls):
pass
class WpBlog(db.Model):
__tablename__ = 'wp_blogs'
__bind_key__ = 'sideka'
blog_id = db.Column('blog_id',
db.Integer,
primary_key=True,
autoincrement=True)
site_id = db.Column('site_id', db.Integer, nullable=False)
domain = db.Column('domain', db.String(length=200), nullable=False)
path = db.Column('path', db.String(length=100), nullable=False)
registered = db.Column('registered',
db.DateTime(timezone=False),
nullable=False)
last_updated = db.Column('last_updated',
db.DateTime(timezone=False),
nullable=False)
public = db.Column('public', db.Integer, nullable=False)
archived = db.Column('archived', db.Integer, nullable=False)
mature = db.Column('mature', db.Integer, nullable=False)
lang_id = db.Column('lang_id', db.Integer, nullable=False)
def __repr__(self):
return '<WpBlog(%r)>' % self.blog_id
class WpUser(db.Model):
__tablename__ = 'wp_users'
__bind_key__ = 'sideka'
ID = db.Column('ID', db.Integer, primary_key=True, nullable=False)
user_login = db.Column('user_login', db.String(length=60), nullable=False)
user_pass = db.Column('user_pass', db.String(length=64), nullable=False)
user_nicename = db.Column('user_nicename',
db.String(length=50),
nullable=False)
user_email = db.Column('user_email', db.String(length=100), nullable=False)
user_url = db.Column('user_url', db.String(length=100), nullable=False)
user_registered = db.Column('user_registered',
db.DateTime(timezone=False),
nullable=False)
user_activation_key = db.Column('user_activation_key',
db.String(length=60),
nullable=False)
user_status = db.Column('user_status', db.Integer, nullable=False)
display_name = db.Column('display_name',
db.String(length=250),
nullable=False)
def __repr__(self):
return '<WpUser(%r)>' % self.user_login
class ContatoModel(db.Model):
__tablename__ = 'tb_contato'
id = db.Column(db.Integer, primary_key=True)
nome = db.Column(db.String(255))
email = db.Column(db.String(255))
telefone = db.Column(db.String(13))
descricao = db.Column(db.Text())
is_atendido = db.Column(db.Boolean, default=False)
dt_insercao = db.Column(db.DateTime, default=func.current_timestamp())
def __init__(self, nome, email, telefone, descricao, is_atendido):
self.nome = nome
self.email = email
self.telefone = telefone
self.descricao = descricao
self.is_atendido = is_atendido
def __str__(self):
return '<Contato %r>' % (self.nome)
from werkzeug.security import generate_password_hash, check_password_hash
from sqlalchemy.exc import SQLAlchemyError
from common.database import db, CRUD
from common.schema import ma
from common.retmsg import ret_msg
from models.nodetree import NodeTree
import uuid
import datetime
admin_m2m_node = db.Table('admin_m2m_node',
db.Column('vip_uuid', db.String(36), db.ForeignKey('Admin.uuid')),
db.Column('node_uuid', db.String(36), db.ForeignKey('NodeTree.node_uuid')))
class Admin(db.Model, CRUD):
__tablename__ = "Admin"
uuid = db.Column(db.String(36), primary_key=True)
phone_number = db.Column(db.String(11), nullable=False)
hash_password = db.Column(db.String(128), nullable=False)
open_id = db.Column(db.String(30))
expire = db.Column(db.DateTime(), default=datetime.datetime.utcnow)
role = db.Column(db.Integer, default=False)
is_active = db.Column(db.Boolean, default=False)
c_time = db.Column(db.DateTime, default=datetime.datetime.utcnow)
l_time = db.Column(db.DateTime)
nodes = db.relationship('NodeTree', secondary=admin_m2m_node, lazy="dynamic", backref=db.backref('users', lazy='joined'))
@property
def password(self):
raise AttributeError('password cannot be read')
@password.setter
class SdUserSupradesa(db.Model):
__tablename__ = 'sd_users_supradesa'
__bind_key__ = 'sideka'
username = db.Column(db.String(length=50), primary_key=True)
supradesa_id = db.Column(db.Integer, primary_key=True)
level = db.Column(db.String(length=50))
class BookStore(db.Model):
__tablename__ = 'book_store'
id = db.Column(db.Integer, primary_key=True)
cashBalance = db.Column(db.Float, nullable=False)
openingHours = db.Column(db.String(200), nullable=False)
storeName = db.Column(db.String(120), nullable=False)
books = db.relationship('Book', backref='book_store', lazy=True)
def __init__(self, storeName, cashBalance, openingHours):
self.storeName = storeName
self.cashBalance = cashBalance
self.openingHours = openingHours
def insert(self):
db.session.add(self)
db.session.commit()
def update(self):
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
@classmethod
def get(cls, storeName):
return cls.query.filter_by(storeName=storeName).first()
@classmethod
def get_all_by_time(cls, time):
return cls.query.filter_by(openingHours=time).all()
@classmethod
def get_all_by_count(cls, count, isGreater):
book_count = (func.count(cls.id)).label("book_count")
if (isGreater == True):
return cls.query. \
join(Book, cls.id == Book.bookStoreId).group_by(cls.id).having(book_count > count).all()
else:
return db.session.query(cls) \
.join(Book, cls.id == Book.bookStoreId).group_by(cls.id).having(book_count < count).all()
@classmethod
def get_all_by_price_and_count(cls, price, count, isGreater):
book_count = (func.count(cls.id)).label("book_count")
if (isGreater == True):
return cls.query.join(Book, cls.id == Book.bookStoreId). \
filter(Book.price <= price).group_by(cls.id).having(book_count > count).all()
else:
return cls.query.join(Book, cls.id == Book.bookStoreId). \
filter(Book.price <= price).group_by(cls.id).having(book_count < count).all()
@classmethod
def get_all_by_key_word(cls, keyword):
search = "%{}%".format(keyword)
return cls.query.filter(cls.storeName.like(search)).order_by(
cls.storeName).all()
@classmethod
def get_all(cls):
return cls.query.all()
from common.schema import ma
from common.database import db, basic_opt
from model.nodetree import NodeTree
node_m2m_msg = db.Table(
't_relate_nodemsg',
db.Column('msg_uuid', db.String(36), db.ForeignKey('NodeMsg.uuid')),
db.Column('node_uuid', db.String(36), db.ForeignKey('NodeTree.node_uuid')))
class NodeMsg(db.Model, basic_opt):
uuid = db.Column(db.Integer, primary_key=True, autoincress=True)
title = db.Column(db.String(128), nullable=False)
msg = db.Column(db.String(256), nullable=False)
nodes = db.relationship('NodeTree',
secondary=node_m2m_msg,
lazy='dynamic',
backref=db.backref('msgs', lazy='joined'))
class OutMsgSchema(ma.Schema):
class Meta:
fields = ('title', 'msg', 'uuid')
class EmpresaModel(db.Model):
__tablename__ = 'tb_empresa'
id = db.Column(db.Integer, primary_key=True)
nome = db.Column(db.String(255), nullable=False)
email = db.Column(db.String(255), nullable=False)
telefone = db.Column(db.String(13), nullable=False)
instagram = db.Column(db.String(255), nullable=True)
facebook = db.Column(db.String(255), nullable=True)
is_delivery = db.Column(db.Boolean, default=False)
is_deleted = db.Column(db.Boolean, default=False)
dt_insercao = db.Column(db.DateTime, default=func.current_timestamp())
fk_id_endereco = db.Column(db.Integer,
db.ForeignKey('tb_endereco.id'),
nullable=False)
endereco = db.relationship(
'EnderecoModel',
backref='endereco',
primaryjoin="EmpresaModel.fk_id_endereco==EnderecoModel.id",
uselist=False)
fk_id_natureza = db.Column(db.Integer,
db.ForeignKey('tb_natureza.id'),
nullable=False)
natureza = db.relationship(
'NaturezaModel',
backref='natureza',
primaryjoin="EmpresaModel.fk_id_natureza==NaturezaModel.id",
uselist=False)
def __init__(self, nome, natureza, endereco, email, telefone, instagram,
facebook, is_delivery):
self.nome = nome
self.natureza = natureza
self.endereco = endereco
self.email = email
self.telefone = telefone
self.instagram = instagram
self.facebook = facebook
self.is_delivery = is_delivery
def __str__(self):
return '<Empresa %r>' % (self.nome)
