class Relatorio(Base):
__tablename__ = 'relatorios'
idRelatorio = db.Column(db.Integer, primary_key=True)
nota = db.Column(db.Integer)
dataSubmissao = db.Column(db.DateTime)
estagioId = db.Column(db.Integer, db.ForeignKey('estagio.idEstagio'))
estagio = db.relationship("Estagio", back_populates="relatorios")
empresaCnpj = db.Column(db.Integer,
db.ForeignKey('empresa.cnpj'),
primary_key=True)
empresa = db.relationship("Empresa", back_populates="relatorios")
alunoNusp = db.Column(db.Integer,
db.ForeignKey('aluno.nusp'),
primary_key=True)
aluno = db.relationship("Aluno", back_populates="relatorios")
def __init__(self, idRelatorio):
self.idRelatorio = idRelatorio
self.dataSubmissao = 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 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 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 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 Offer(db.Model):
offer_id = db.Column(db.Integer, primary_key=True)
offered_item = db.Column(db.Integer,
db.ForeignKey(Item.item_id),
nullable=False)
wanted_item = db.Column(db.Integer,
db.ForeignKey(Item.item_id),
nullable=False)
date_created = db.Column(db.DateTime)
accepted = db.Column(db.Boolean)
def __repr__(self):
return f"<OFFER> {self.offer_id}"
class Voo(Base):
__tablename__ = 'voo'
id = db.Column(db.Integer, primary_key=True)
id_piloto = db.Column(db.Integer,
db.ForeignKey('piloto.id'),
primary_key=True)
duracao = db.Column(db.Integer, unique=True)
data = db.Column(db.DateTime)
def __init__(self, id_piloto, duracao, data):
self.id_piloto = id_piloto
self.duracao = duracao
self.data = data
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_id_piloto(cls, id_piloto):
return cls.query.filter_by(id_piloto=id_piloto).first()
@classmethod
def listar(cls):
return cls.query.all()
def remover(self):
db.session.delete(self)
db.session.commit()
class Certificado(Base):
__tablename__ = 'certificado'
id = db.Column(db.Integer, primary_key=True)
id_aluno = db.Column(db.Integer,
db.ForeignKey('aluno.id'),
primary_key=True)
data = db.Column(db.DateTime)
def __init__(self, id_aluno):
self.id_aluno = id_aluno
self.data = 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_id_aluno(cls, id_aluno):
return cls.query.filter_by(id_aluno=id_aluno).first()
@classmethod
def listar(cls):
return cls.query.all()
def remover(self):
db.session.delete(self)
db.session.commit()
class ItemLista(Base):
__tablename__ = 'itenslistas'
lista_id = db.Column(db.Integer,
db.ForeignKey('listas.id'),
primary_key=True)
item_id = db.Column(db.Integer,
db.ForeignKey('itens.id'),
primary_key=True)
preco = db.Column(db.String(100))
item = db.relationship("ItemModel", back_populates="listas", uselist=False)
lista = db.relationship("ListaModel",
back_populates="itens",
uselist=False)
def __init__(self, preco):
self.preco = preco
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 Horario(Base):
__tablename__ = 'horario'
id = db.Column(db.Integer, primary_key=True)
id_instrutor = db.Column(db.Integer,
db.ForeignKey('instrutor.id'),
primary_key=True)
data_inicio = db.Column(db.DateTime)
data_fim = db.Column(db.DateTime)
def __init__(self, id_instrutor, data_inicio, data_fim):
self.id_instrutor = id_instrutor
self.data_inicio = data_inicio
self.data_fim = data_fim
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_id_instrutor(cls, id_instrutor):
return cls.query.filter_by(id_instrutor=id_instrutor).first()
@classmethod
def listar(cls):
return cls.query.all()
def remover(self):
db.session.delete(self)
db.session.commit()
class Estagio(Base):
__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()
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 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 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 Aula(Voo):
__tablename__ = 'aula'
id = db.Column(db.Integer, db.ForeignKey('voo.id'), primary_key=True)
id_aluno = db.Column(db.Integer,
db.ForeignKey('pessoa.id'),
primary_key=True)
id_instrutor = db.Column(db.Integer,
db.ForeignKey('pessoa.id'),
primary_key=True)
def __init__(self, id_aluno, id_instrutor, duracao, data):
self.id_aluno = id_aluno
self.id_instrutor = id_instrutor
self.duracao = duracao
self.data = data
@classmethod
def encontrar_pelo_id_aluno(cls, id_aluno):
return cls.query.filter_by(id_aluno=id_aluno).first()
@classmethod
def encontrar_pelo_id_instrutor(cls, id_instrutor):
return cls.query.filter_by(id_instrutor=id_instrutor).first()
class AulaModel(Base):
__tablename__ = 'aulas'
id = db.Column(
db.Integer,
primary_key=True) # chave primaria unica e auto-incrementada
data = db.Column(db.DateTime, nullable=False) # AAAA-MM-DDTHH:MM:SS
aluno_id = db.Column(db.Integer,
db.ForeignKey('alunos.id'),
nullable=False)
aluno = db.relationship("AlunoModel", backref="aulas")
duracao = db.Column(db.Integer, nullable=False)
parecer = db.Column(db.Integer, nullable=False)
def __init__(self, aluno_id, data, duracao, parecer):
self.data = data
self.aluno_id = aluno_id
self.duracao = duracao
self.parecer = parecer
# adiciona uma linha na respectiva tabela
def add(self):
db.session.add(self)
db.session.commit()
# encontra aulas alocadas ao aluno
@classmethod
def find_by_aluno_id(cls, aluno_id):
return cls.query.filter_by(aluno_id=aluno_id).first()
# encontra aulas por data
@classmethod
def find_by_data(cls, data):
return cls.query.filter_by(data=data).all()
# encontra aula especifica (data e aluno_id)
@classmethod
def find_by_data_aluno_id(cls, data, aluno_id):
return cls.query.filter_by(data=data, aluno_id=aluno_id).first()
# lista todas as aulas
@classmethod
def list(cls):
return cls.query.all()
# remove uma linha da tabela
def remove(self):
db.session.delete(self)
db.session.commit()
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 Relatorio(db.Model):
__tablename__ = 'relatorios'
idRelatorio = db.Column(db.Integer, primary_key=True)
nota = db.Column(db.Integer)
dataSubmissao = db.Column(db.DateTime)
estagioId = db.Column(db.Integer, db.ForeignKey('estagio.idEstagio'))
# estagio = db.relationship("Estagio", back_populates="relatorios")
# empresaCnpj = db.Column(db.Integer, db.ForeignKey(
# 'empresa.cnpj'), primary_key=True)
# empresa = db.relationship("Empresa", back_populates="relatorios")
# alunoNusp = db.Column(db.Integer, db.ForeignKey(
# 'aluno.nusp'), primary_key=True)
# aluno = db.relationship("Aluno", back_populates="relatorios")
def __init__(self, idRelatorio):
self.idRelatorio = idRelatorio
self.dataSubmissao = datetime.now()
from _md5 import md5
from flask_login import UserMixin
from werkzeug.security import check_password_hash, generate_password_hash
from dao import db
from datetime import datetime
from webapp import login
# direct declare table
followers = db.Table(
'followers', db.Column('follower_id', db.Integer,
db.ForeignKey('user.id')),
db.Column('followed_id', db.Integer, db.ForeignKey('user.id')))
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),
class Prova(Aula):
__tablename__ = 'prova'
id = db.Column(db.Integer, db.ForeignKey('aula.id'), primary_key=True)
nota = db.Column(db.Integer, unique=True)
from werkzeug.security import generate_password_hash, check_password_hash
from dao import db
inventory = db.Table(
"inventory",
db.Column("inventory_id", db.Integer, primary_key=True),
db.Column("character_id", db.Integer,
db.ForeignKey("character.character_id")),
db.Column("item_id", db.Integer, db.ForeignKey("item.item_id")),
)
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)
