class UsuarioModel(Base):
__tablename__ = 'usuarios'
id = db.Column(db.Integer, primary_key=True)
nome = db.Column(db.String(200), unique=True)
email = db.Column(db.String(200), unique=True)
dataCadastro = db.Column(db.DateTime)
listas = db.relationship("ListaModel", back_populates="usuario")
def __init__(self, nome, email):
self.nome = nome
self.email = email
self.dataCadastro = datetime.now()
def adicionar(self):
db.session.add(self)
db.session.commit()
@classmethod
def encontrar_pelo_id(cls, _id):
return cls.query.filter_by(id=_id).first()
@classmethod
def encontrar_pelo_nome(cls, nome):
return cls.query.filter_by(nome=nome).first()
@classmethod
def listar(cls):
return cls.query.all()
def remover(self):
db.session.delete(self)
db.session.commit()
class User(db.Model):
user_id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80), nullable=False)
email = db.Column(db.String(80), nullable=False, unique=True)
dci = db.Column(db.String(10), nullable=False, unique=True)
password = db.Column(db.String(128), nullable=False)
active = db.Column(db.Boolean, default=True)
verified = db.Column(db.Boolean, default=False)
last_login = db.Column(db.DateTime)
authenticated = db.Column(db.Boolean, default=False)
characters = db.relationship('Character', backref='character', lazy=True)
def __repr__(self):
return f"<USER> {self.user_id}: {self.email}"
def set_password(self, password):
self.password = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password, password)
def is_active(self):
return self.active
def get_id(self):
return self.email
def is_authenticated(self):
return self.authenticated
def is_anonymous(self):
return False
class Item(Base):
__tablename__ = 'itens'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80), unique=False)
description = db.Column(db.String(300), unique=False)
price = db.Column(db.String(25), unique=False)
author = db.Column(db.String(100), unique=False)
photo = db.Column(db.String(500), unique=False)
# pedido_id = db.Column(db.Integer, db.ForeignKey('pedidos.id'),
# nullable=False)
def __init__(self, name, description, price, author, photo):
self.name = name
self.description = description
self.price = price
self.author = author
self.photo = photo
def to_dict(self):
response = {
"id": self.id,
"name": self.name,
"description": self.description,
"price": self.price,
"author": self.author,
"photo": self.photo
}
return response
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
body = db.Column(db.String(140))
timestamp = db.Column(db.DateTime, index=True, default=datetime.utcnow)
user_name = db.Column(db.String(64), db.ForeignKey('user.username'))
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
def __repr__(self):
return '<Post {}>'.format(self.body)
class User(UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), index=True, unique=True)
email = db.Column(db.String(120), index=True, unique=True)
password_hash = db.Column(db.String(128))
about_me = db.Column(db.String(512), nullable=True)
last_seen = db.Column(db.DateTime, default=datetime.utcnow)
# many to many relationship usage: user1.followed.append(user2)
followed = db.relationship(
'User',
secondary=followers,
# that links the left side entity user1
primaryjoin=(followers.c.follower_id == id),
# that links the right side entity user2
secondaryjoin=(followers.c.followed_id == id),
backref=db.backref('followers', lazy='dynamic'),
lazy='dynamic')
def __repr__(self):
return '<User {}>'.format(self.username)
def avatar(self, size):
digest = md5(self.email.lower().encode('utf-8')).hexdigest()
return 'https://www.gravatar.com/avatar/{}?d=identicon&s={}'.format(
digest, size)
@login.user_loader
def load_user(id):
return User.query.get(int(id))
def set_password(self, password):
self.password_hash = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password_hash, password)
def follow(self, user):
if not self.is_following(user):
self.followed.append(user)
def unfollow(self, user):
if self.is_following(user):
self.followed.remove(user)
def is_following(self, user):
return self.followed.filter(
followers.c.followed_id == user.id).count() > 0
def followerPosts(self):
# select * from posts left join followers on posts.user_id = followers.followed_id where follower_id = #self.id#
followed = Post.query.join(
followers, (followers.c.followed_id == Post.user_id)).filter(
followers.c.follower_id == self.id)
own = Post.query.filter_by(user_id=self.id)
return followed.union(own).order_by(Post.timestamp.desc())
class Aluno(Base):
__tablename__ = 'alunos'
nusp = db.Column(db.Integer, primary_key=True)
nome = db.Column(db.String(200))
cpf = db.Column(db.String(30), unique=True)
curso = db.Column(db.String(30))
ano = db.Column(db.Integer)
telefone = db.Column(db.string(10))
email = db.Column(db.string(40), unique=True)
data_nasc = db.Column(db.DateTime)
endereco = db.Column(db.string(50))
curriculo = db.Column(db.text)
# listas = db.relationship("ItemLista", back_populates="item")
# estagios
# relatorios
# vagas candidatados
def __init__(self, nome, nusp):
self.nome = nome
self.nusp = nusp
def adicionar(self):
db.session.add(self)
db.session.commit()
@classmethod
def encontrar_aluno_pelo_nusp(cls, _nusp):
return cls.query("alunos").filter_by(nusp=_nusp).first()
@classmethod
def encontrar_aluno_pelo_nome(cls, nome):
return cls.query("alunos").filter_by(nome=nome).first()
@classmethod
def listar(cls):
return cls.query("alunos").all()
def update_perfil(self, nome, nusp, cpf, curso, ano, telefone, email,
data_nasc, endereco, curriculo):
self.nome = nome
self.nusp = nusp
self.cpf = cpf
self.curso = curso
self.ano = ano
self.telefone = telefone
self.email = email
self.data_nasc = data_nas
self.endereco = endereco
self.curriculo = curriculo
def remover(self):
db.session.delete(self)
db.session.commit()
class SessionUser(db.Model):
__tablename__ = 'users'
username = db.Column(db.String, primary_key=True)
name = db.Column(db.String(50), unique=True)
password = db.Column(db.String(20), unique=True)
def __init__(self, username=None, name=None, password=None):
self.username = username
self.name = name
self.password = password
def __repr__(self):
return '<SessionUser %r>' % self.name
class ServicoModel(Base):
__tablename__ = 'servicos'
id = db.Column(db.Integer, primary_key=True)
id_cliente = db.Column(db.String(200), db.ForeignKey('clientes.id'))
id_fornecedor = db.Column(db.String(200), db.ForeignKey('fornecedores.id'))
servico = db.Column(db.String(200))
rank = db.Column(db.Integer)
contato_fornecedor = db.Column(db.String(200))
contato_cliente = db.Column(db.String(200))
data = db.Column(db.DateTime)
data_criacao = db.Column(db.DateTime)
def __init__(self, id_cliente, id_fornecedor, servico, contato_fornecedor, contato_cliente, data):
self.id_cliente = id_cliente
self.id_fornecedor = id_fornecedor
self.servico = servico
self.rank = 0
self.contato_fornecedor = contato_fornecedor
self.contato_cliente = contato_cliente
self.data = datetime.strptime(data, '%d/%m/%Y')
self.data_criacao = datetime.now()
def adicionar(self):
db.session.add(self)
db.session.commit()
@classmethod
def modificar(cls, _id, data):
newItem = cls.query.filter_by(id=_id).first()
newItem.servico = data['servico']
newItem.rank = data['rank']
newItem.contato_fornecedor = data['contato_fornecedor']
newItem.contato_cliente = data['contato_cliente']
newItem.data = data['data']
db.session.commit()
@classmethod
def encontrar_pelo_id(cls, id):
return cls.query.filter_by(id=id).first()
@classmethod
def listar(cls, _id, _tipo):
if _tipo == 1:
return cls.query.all()
if _tipo == 2:
return cls.query.filter_by(id_fornecedor=_id)
return cls.query.filter_by(id_cliente=_id)
def remover(self):
db.session.delete(self)
db.session.commit()
class Vagas(db.Model):
__tablename__ = 'vagas'
nome = db.Column(db.String(200))
idVaga = db.Column(db.Integer, primary_key=True)
area = db.Column(db.String(50))
beneficios = db.Column(db.String(500))
remuneracao = db.Column(db.String(20))
requisitos = db.Column(db.String(500))
etapasProc = db.Column(db.String(500))
descricao = db.Column(db.String(500))
duracaoMeses = db.Column(db.Integer)
aprovadaParaDivulgar = db.Column(db.Boolean)
dataCadastro = db.Column(db.DateTime)
nomeEmpresa = db.Column(db.String(200))
# empresaCnpj = db.Column(db.Integer, db.ForeignKey(
# 'empresa.cnpj'), primary_key=True)
# empresa = db.relationship("Empresa", back_populates="vagas")
# alunoNusp = db.Column(db.Integer, db.ForeignKey(
# 'aluno.nusp'), primary_key=True)
# aluno = db.relationship("Aluno", back_populates="vagas")
def __init__(self, nome):
self.nome = nome
# self.empresa = empresa
self.dataCadastro = datetime.now()
class Pessoa(Base):
__tablename__ = 'pessoa'
id = db.Column(db.Integer, primary_key=True)
nome = db.Column(db.String(200), unique=True)
cpf = db.Column(db.Integer, unique=True)
email = db.Column(db.String(200), unique=True)
data_nascimento = db.Column(db.DateTime)
cargo = db.Column(db.String(200), unique=False)
dataCadastro = db.Column(db.DateTime)
cod_curso = db.Column(db.String(200), unique=False)
def __init__(self, nome, cpf, email, cargo, data_nascimento):
self.nome = nome
self.cpf = cpf
self.email = email
self.data_nascimento = data_nascimento
self.cargo = cargo
self.dataCadastro = datetime.now()
def adicionar(self):
db.session.add(self)
db.session.commit()
@classmethod
def encontrar_pelo_id(cls, _id):
return cls.query.filter_by(id=_id).first()
@classmethod
def encontrar_pelo_nome(cls, nome):
return cls.query.filter_by(nome=nome).first()
@classmethod
def encontrar_pelo_cpf(cls, cpf):
return cls.query.filter_by(cpf=cpf).first()
@classmethod
def encontrar_por_cargo(cls, cargo):
return cls.query.filter_by(cargo=cargo).all()
@classmethod
def encontrar_pelo_email(cls, email):
return cls.query.filter_by(email=email).first()
@classmethod
def listar(cls):
return cls.query.all()
def remover(self):
db.session.delete(self)
db.session.commit()
class Item(db.Model):
item_id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80), nullable=False)
type_ = db.Column(db.String(80), nullable=False)
rarity = db.Column(db.String(30), nullable=False)
attuned = db.Column(db.Boolean, nullable=False)
notes = db.Column(db.String(300), nullable=False)
source = db.Column(db.String(10), nullable=False)
characters = db.relationship("Character",
secondary=inventory,
lazy="subquery")
def __repr__(self):
return f"<ITEM_CLASS> {self.item_id}: {self.name}"
class DemandaModel(Base):
__tablename__ = 'demandas'
id = db.Column(db.Integer, primary_key=True)
cliente_id = db.Column(db.Integer, db.ForeignKey("clientes.id"))
status = db.Column(db.String(200))
custo = db.Column(db.String(200))
problema = db.Column(db.String(10000))
solucao = db.Column(db.String(10000))
data_criacao = db.Column(db.DateTime)
def __init__(self, cliente_id, status, custo, problema, solucao):
self.status = status
self.cliente_id = cliente_id
self.custo = custo
self.problema = problema
self.solucao = solucao
self.data_criacao = datetime.now()
def adicionar(self):
db.session.add(self)
db.session.commit()
@classmethod
def modificar(cls, _id, data):
newItem = cls.query.filter_by(id=_id).first()
newItem.status = data['status']
newItem.custo = data['custo']
newItem.problema = data['problema']
newItem.solucao = data['solucao']
db.session.commit()
@classmethod
def encontrar_pelo_id(cls, _id):
return cls.query.filter_by(id=_id).first()
@classmethod
def encontrar_pelo_email(cls, _email):
return cls.query.filter_by(email=_email).first()
@classmethod
def listar(cls, _id):
if _id == 1:
return cls.query.all()
return cls.query.filter_by(cliente_id=_id)
def remover(self):
db.session.delete(self)
db.session.commit()
class AlunoModel(Base):
__tablename__ = 'alunos'
id = db.Column(db.Integer, primary_key=True)
matricula = db.Column(db.Integer, unique = True)
nome = db.Column(db.String(200), unique=True)
#data_criacao = db.Column(db.DateTime)
voos = db.relationship("VooModel", lazy = 'dynamic')
def __init__(self, nome, matricula):
self.nome = nome
# self.data_criacao = datetime.now()
def adicionar(self):
db.session.add(self)
db.session.commit()
@classmethod
def encontrar_pela_matricula(cls, _matricula):
return cls.query.filter_by(matricula=_matricula).first()
@classmethod
def encontrar_pelo_nome(cls, _nome):
return cls.query.filter_by(nome=_nome).first()
@classmethod
def listar(cls):
return cls.query.all()
def remover(self):
db.session.delete(self)
db.session.commit()
class Aviao(Base):
__tablename__ = 'aviao'
id = db.Column(db.Integer, primary_key=True)
modelo = db.Column(db.String(200), unique=True)
data_fabricacao = db.Column(db.DateTime)
def __init__(self, modelo, data_fabricacao):
self.nome = modelo
self.data_fabricacao = data_fabricacao
def adicionar(self):
db.session.add(self)
db.session.commit()
@classmethod
def encontrar_pelo_id(cls, _id):
return cls.query.filter_by(id=_id).first()
@classmethod
def encontrar_pelo_modelo(cls, modelo):
return cls.query.filter_by(modelo=modelo).first()
@classmethod
def listar(cls):
return cls.query.all()
def remover(self):
db.session.delete(self)
db.session.commit()
class VooModel(Base):
__tablename__ = 'voos'
id = db.Column(db.Integer, primary_key=True)
#matricula = db.Column(db.Integer, unique = True)
duracao = db.Column(db.String(200))
data = db.Column(db.DateTime)
parecer = db.Column(db.Integer)
aluno_nome = db.Column(db.Integer, db.ForeignKey('alunos.nome'))
instrutor_nome = db.Column(db.Integer, db.ForeignKey('instrutores.nome'))
voo_aluno = db.relationship("AlunoModel")
voo_instrutor = db.relationship("InstrutorModel")
def __init__(self, duracao, parecer, aluno_nome, instrutor_nome):
self.duracao = duracao
self.parecer = parecer
self.aluno_nome = aluno_nome
self.instrutor_nome = instrutor_nome
def adicionar(self):
db.session.add(self)
db.session.commit()
@classmethod
def encontrar_pelo_id(cls, _id):
return cls.query.filter_by(id=_id).first()
@classmethod
def listar(cls):
return cls.query.all()
def remover(self):
db.session.delete(self)
db.session.commit()
class Pedidos(Base):
__tablename__ = 'pedidos'
id = db.Column(db.Integer, primary_key=True)
data = db.Column(db.DateTime, nullable=False)
codigo = db.Column(db.DateTime, nullable=False)
status = db.Column(db.String(25), unique=False)
# itens = db.Column(db.ARRAY(db.relationship('Item', secondary="pedido_item", lazy='subquery',
# backref=db.backref('pedidos', lazy=True))))
# itens = db.relationship('Item', backref='pedidos', lazy=True)
def __init__(self, data, codigo, status, user_id):
self.data = data
self.codigo = codigo
self.status = status
self.user_id = user_id
# self.itens = itens
def to_dict(self):
response = {
"id": self.id,
"user_id": self.user_id,
# "itens": self.itens,
"data": self.data,
"codigo": self.codigo,
"status": self.status
}
return response
class ListaModel(Base):
__tablename__ = 'listas'
id = db.Column(db.Integer, primary_key=True)
nome = db.Column(db.String(200), unique=True)
usuario_id = db.Column(db.Integer,db.ForeignKey("usuarios.id"))
usuario = db.relationship("UsuarioModel", back_populates="listas")
dataCadastro = db.Column(db.DateTime)
itens = db.relationship("ItemLista", back_populates="lista")
def __init__(self,nome,usuario_id):
self.nome = nome
self.usuario_id = usuario_id
self.dataCadastro = datetime.now()
def adicionar(self):
db.session.add(self)
db.session.commit()
@classmethod
def encontrar_pelo_id(cls, _id):
return cls.query.filter_by(id=_id).first()
@classmethod
def encontrar_pelo_nome(cls, nome):
return cls.query.filter_by(nome=nome).first()
@classmethod
def listar(cls):
return cls.query.all()
def remover(self):
db.session.delete(self)
db.session.commit()
class ItemModel(Base):
__tablename__ = 'itens'
id = db.Column(db.Integer, primary_key=True)
nome = db.Column(db.String(200), unique=True)
data_criacao = db.Column(db.DateTime)
listas = db.relationship("ItemLista", back_populates="item")
def __init__(self, nome):
self.nome = nome
self.data_criacao = datetime.now()
def adicionar(self):
db.session.add(self)
db.session.commit()
@classmethod
def encontrar_pelo_id(cls, _id):
return cls.query.filter_by(id=_id).first()
@classmethod
def encontrar_pelo_nome(cls, nome):
return cls.query.filter_by(nome=nome).first()
@classmethod
def listar(cls):
return cls.query.all()
def remover(self):
db.session.delete(self)
db.session.commit()
class Professor(Base):
__tablename__ = 'professores'
cpf = db.Column(db.Integer, primary_key=True)
nome = db.Column(db.String(200))
email = db.Column(db.string(40), unique=True)
dataCadastro = db.Column(db.DateTime)
# listas = db.relationship("ItemLista", back_populates="item")
# estagios
# estagios pendentes
# relatorios
# vagas pendentes
def __init__(self, nome, cpf):
self.nome = nome
self.cpf = cpf
self.dataCadastro = datetime.now()
def adicionar(self):
db.session.add(self)
db.session.commit()
@classmethod
def listar(cls):
return cls.query.all()
def remover(self):
db.session.delete(self)
db.session.commit()
class Curso(Base):
__tablename__ = 'curso'
id = db.Column(db.Integer, primary_key=True)
nome = db.Column(db.String(200), unique=True)
n_voos = db.Column(db.Integer)
def __init__(self, nome, n_voos):
self.nome = nome
self.n_voos = n_voos
def adicionar(self):
db.session.add(self)
db.session.commit()
@classmethod
def encontrar_pelo_id(cls, _id):
return cls.query.filter_by(id=_id).first()
@classmethod
def encontrar_pelo_nome(cls, nome):
return cls.query.filter_by(nome=nome).first()
@classmethod
def listar(cls):
return cls.query.all()
def remover(self):
db.session.delete(self)
db.session.commit()
class Estagio(db.Model):
__tablename__ = 'estagios'
nome = db.Column(db.String(200))
idEstagio = db.Column(db.Integer, primary_key=True)
inicio = db.Column(db.DateTime)
fim = db.Column(db.DateTime)
duracaoMeses = db.Column(db.Integer)
aprovadoParaIniciar = db.Column(db.Boolean)
# empresaCnpj = db.Column(db.Integer, db.ForeignKey(
# 'empresa.cnpj'), primary_key=True)
# empresa = db.relationship("Empresa", back_populates="estagios")
# alunoNusp = db.Column(db.Integer, db.ForeignKey(
# 'aluno.nusp'), primary_key=True)
# aluno = db.relationship("Aluno", back_populates="estagios")
# relatorioAluno = db.Column(db.Integer, db.ForeignKey(
# 'relatorio.idRelatorio'), primary_key=True)
# relatorioEmpresa = db.Column(db.Integer, db.ForeignKey(
# 'relatorio.idRelatorio'), primary_key=True)
# relatorio = db.relationship("Relatorio", back_populates="estagios")
def __init__(self, nome, idEstagio):
self.nome = nome
self.idEstagio = idEstagio
self.inicio = datetime.now()
class Professor(db.Model):
__tablename__ = 'professores'
cpf = db.Column(db.Integer, primary_key=True)
nome = db.Column(db.String(200))
email = db.Column(db.String(40), unique=True)
dataCadastro = db.Column(db.DateTime)
# estagios
# estagios pendentes
# relatorios
# vagas pendentes
def __init__(self, nome, cpf):
self.nome = nome
self.cpf = cpf
self.dataCadastro = datetime.now()
class GestorModel(Base): __tablename__ = 'usuarios' id = db.Column(db.Integer, primary_key=True) nome = db.Column(db.String(200)) senha = db.Column(db.String(200)) email = db.Column(db.String(200), unique=True) tipo = db.Column(db.Integer) dataCadastro = db.Column(db.DateTime) def __init__(self,nome,senha,email,tipo): self.nome = nome self.senha = senha self.email = email self.tipo = tipo self.dataCadastro = datetime.now() def adicionar(self): db.session.add(self) db.session.commit() @classmethod def modificar(cls, _id, data): newItem = cls.query.filter_by(id=_id).first() newItem.nome = data['nome'] newItem.senha = data['senha'] newItem.email = data['email'] newItem.tipo = data['tipo'] db.session.commit() @classmethod def encontrar_pelo_id(cls, _id): return cls.query.filter_by(id=_id).first() @classmethod def encontrar_pelo_email(cls, _email): return cls.query.filter_by(email=_email).first() @classmethod def listar(cls): return cls.query.all() def remover(self): db.session.delete(self) db.session.commit()
class Vagas(Base):
__tablename__ = 'vagas'
nome = db.Column(db.String(200))
idVaga = db.Column(db.Integer, primary_key=True)
area = db.Column(db.String(50))
beneficios = db.Column(db.text)
remuneracao = db.Column(db.String(20))
requisitos = db.Column(db.text)
etapasProc = db.Column(db.text)
descricao = db.Column(db.text)
duracaoMeses = db.Column(db.Integer)
aprovadaParaDivulgar = db.Column(db.Boolean)
dataCadastro = db.Column(db.DateTime)
empresaCnpj = db.Column(db.Integer, db.ForeignKey(
'empresa.cnpj'), primary_key=True)
empresa = db.relationship("Empresa", back_populates="vagas")
alunoNusp = db.Column(db.Integer, db.ForeignKey(
'aluno.nusp'), primary_key=True)
aluno = db.relationship("Aluno", back_populates="vagas")
def __init__(self, nome, idVaga, empresa):
self.nome = nome
self.idVaga = idVaga
self.empresa = empresa
self.dataCadastro = datetime.now()
def adicionar(self):
db.session.add(self)
db.session.commit()
@classmethod
def encontrar_pelo_nome(cls, nome):
return cls.query.filter_by(nome=nome)
@classmethod
def listar(cls):
return cls.query.all()
def remover(self):
db.session.delete(self)
db.session.commit()
class Empresa(db.Model):
__tablename__ = 'empresas'
cnpj = db.Column(db.Integer, primary_key=True)
nome = db.Column(db.String(200))
email = db.Column(db.String(40), unique=True)
endereco = db.Column(db.String(50))
valores = db.Column(db.String(500))
dataCadastro = db.Column(db.DateTime)
# estagios
# relatorios
# vagas cadastradas
def __init__(self, nome, cnpj):
self.nome = nome
self.cnpj = cnpj
self.dataCadastro = datetime.now()
def adicionar(self):
db.session.add(self)
db.session.commit()
class ClienteModel(Base):
__tablename__ = 'clientes'
id = db.Column(db.Integer, primary_key=True)
empresa = db.Column(db.String(200), unique=True)
senha = db.Column(db.String(200))
email = db.Column(db.String(200), unique=True)
nome = db.Column(db.String(200))
endereco = db.Column(db.String(200))
cnpj = db.Column(db.String(200), unique=True)
tipo = db.Column(db.Integer)
ativo = db.Column(db.DateTime)
dataCadastro = db.Column(db.DateTime)
listaDemanda = db.relationship("DemandaModel")
listaServico = db.relationship("ServicoModel")
def __init__(self, empresa, senha, email, nome, endereco, cnpj, tipo):
self.nome = nome
self.empresa = empresa
self.senha = senha
self.email = email
self.nome = nome
self.endereco = endereco
self.cnpj = cnpj
self.tipo = tipo
self.ativo = None
self.dataCadastro = datetime.now()
def adicionar(self):
db.session.add(self)
db.session.commit()
@classmethod
def modificar(cls, _id, data):
newItem = cls.query.filter_by(id=_id).first()
newItem.nome = data['nome']
newItem.empresa = data['empresa']
newItem.senha = data['senha']
newItem.email = data['email']
newItem.nome = data['nome']
newItem.endereco = data['endereco']
newItem.cnpj = data['cnpj']
newItem.tipo = data['tipo']
db.session.commit()
@classmethod
def encontrar_pelo_id(cls, _id):
return cls.query.filter_by(id=_id).first()
@classmethod
def encontrar_pelo_email(cls, _email):
return cls.query.filter_by(email=_email).first()
@classmethod
def listar(cls):
return cls.query.all()
def remover(self):
db.session.delete(self)
db.session.commit()
class SampleB(db.Model):
__tablename__ = 'sample_b'
id_field_b = db.Column(db.Integer, primary_key=True)
id_field_a = db.Column(db.Integer, primary_key=True)
text_field_b = db.Column(db.String(50), unique=True)
def __init__(self, text_field_b=None, id_field_b=None, id_field_a=None):
self.id_field_b = id_field_b
self.id_field_a = id_field_a
self.text_field_b = text_field_b
def __repr__(self):
return '<SampleB %r>' % self.id_field_b + ' - ' + self.id_field_a
class Character(db.Model):
character_id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80), nullable=False)
user_id = db.Column(db.Integer,
db.ForeignKey(User.user_id),
nullable=False)
user = db.relationship("User", backref=db.backref("user"), lazy=True)
items = db.relationship("Item", secondary=inventory, lazy="subquery")
def __repr__(self):
return f"<CHARACTER> {self.character_id}: {self.name}"
class User(Base):
__tablename__ = 'usuarios'
id = db.Column(db.Integer, primary_key=True)
nome = db.Column(db.String(80), unique=False)
cpf = db.Column(db.String(20), unique=True)
email = db.Column(db.String(120), unique=True)
endereco = db.Column(db.String(200), unique=False)
telefone = db.Column(db.String(40), unique=False)
artista = db.Column(db.Boolean, unique=False)
# pedidos_id = Column(Integer, ForeignKey('pedidos.id'))
# pedidos = db.relationship('Pedidos', backref='usuarios', lazy=True)
# itens = db.Column(db.ARRAY(db.relationship('Item', secondary="pedido_item", lazy='subquery',
# backref=db.backref('pedidos', lazy=True))))
def __init__(self, nome, email, cpf, endereco, telefone, artista):
self.nome = nome
self.email = email
self.cpf = cpf
self.endereco = endereco
self.telefone = telefone
self.artista = artista
# self.pedidos = pedidos
def to_dict(self):
response = {
"id": self.id,
"nome": self.nome,
"email": self.email,
"cpf": self.cpf,
"endereco": self.endereco,
"telefone": self.telefone,
"artista": self.artista
# "pedidos": self.pedidos
}
return response
class TesteModel(Base):
__tablename__ = 'teste'
id = db.Column(db.Integer, primary_key=True)
empresa = db.Column(db.String(200))
senha = db.Column(db.String(200))
def __init__(self, empresa, senha):
self.empresa = empresa
self.senha = senha
def adicionar(self):
db.session.add(self)
db.session.commit()
@classmethod
def modificar(cls, _id, data):
newItem = cls.query.filter_by(id=_id).first()
newItem.empresa = data['empresa']
newItem.senha = data['senha']
db.session.commit()
@classmethod
def encontrar_pelo_id(cls, id):
return cls.query.filter_by(id=id).first()
@classmethod
def listar(cls, _id, _tipo):
if _tipo == 1:
return cls.query.all()
if _tipo == 2:
return cls.query.filter_by(empresa="usp")
return cls.query.filter_by(id=id).first()
def remover(self):
db.session.delete(self)
db.session.commit()
