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 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 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 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 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 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 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 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 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 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 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 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 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 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 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()