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 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 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 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 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 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 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 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 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 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 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 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 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(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 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 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 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 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 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 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 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 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 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()
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 Consultant(Base):
__tablename__ = 'consultores'
id_consultant = db.Column(db.Integer, primary_key=True)
cpf = ''
email = ''
rating = 0
orders = []
def __init__(self, id_consultant):
self.id_consultant = id_consultant
class SampleA(db.Model):
__tablename__ = 'sample_a'
id_field_a = db.Column(db.Integer, primary_key=True)
text_field_a = db.Column(db.String(50), unique=True)
numeric_field_a = db.Column(db.Integer, unique=True)
date_field_a = db.Column(db.Date, unique=True)
def __init__(self,
text_field_a=None,
numeric_field_a=None,
date_field_a=None,
id_field_a=None):
self.id_field_a = id_field_a
self.text_field_a = text_field_a
self.numeric_field_a = numeric_field_a
self.date_field_a = date_field_a
def __repr__(self):
return '<SampleA %r>' % self.id_field_a
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 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 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()
