class Genero(db.Model):
__tablename__ = 'genero'
id = db.Column(db.Integer, primary_key=True)
nombre = db.Column(db.String)
def get_all():
return Genero.query.all()
class Barrio(db.Model):
__tablename__ = 'barrio'
id = db.Column(db.Integer, primary_key=True)
nombre = db.Column(db.String)
def get_all():
return Barrio.query.all()
class Asistencia_estudiante_taller(db.Model):
__tablename__ = 'asistencia_estudiante_taller'
__table_args__ = (PrimaryKeyConstraint('estudiante_id', 'ciclo_lectivo_id',
'taller_id'), )
id = db.Column(db.Integer, primary_key=True)
estudiante_id = db.Column(db.Integer, ForeignKey(estudiante.Estudiante.id))
ciclo_lectivo_id = db.Column(db.Integer,
ForeignKey(ciclo_lectivo.Ciclo_lectivo.id))
taller_id = db.Column(db.Integer, ForeignKey(taller.Taller.id))
fecha = db.Column(db.String)
def get(id):
return Asistencia_estudiante_taller.query.filter_by(id=id).first()
def all():
return Asistencia_estudiante_taller.query.all()
def get(eid, cid, taid):
return Asistencia_estudiante_taller.query.filter_by(
estudiante_id=eid, ciclo_lectivo_id=cid, taller_id=taid).first()
def create(eid, cid, taid):
elemento = Asistencia_estudiante_taller(estudiante_id=eid,
ciclo_lectivo_id=cid,
taller_id=taid)
elemento.fecha = datetime.now()
db.session.add(elemento)
db.session.commit()
return True
class Responsable(db.Model):
__tablename__ = "responsable"
id = db.Column(db.Integer, primary_key=True)
apellido = db.Column(db.String(255), nullable=False)
nombre = db.Column(db.String(255), nullable=False)
fecha_nac = db.Column(db.DateTime, nullable=False)
localidad = db.Column(db.String(255), nullable=False)
domicilio = db.Column(db.String(255), nullable=False)
genero_id = db.Column(db.Integer, db.ForeignKey('genero.id'))
genero = db.relationship(Genero, backref = backref('estudiantes', uselist = True, cascade = 'delete,all'))
tipo_documento = db.Column(db.String(255), nullable=False)
numero = db.Column(db.Integer, nullable=False, unique=True)
telefono = db.Column(db.String(255), nullable=False, unique=True)
def __init__(self, apellido, nombre, fecha_nac, localidad, domicilio, genero, tipo_documento, numero, telefono):
self.apellido = apellido
self.nombre = nombre
self.fecha_nac = fecha_nac
self.localidad = localidad
self.domicilio = domicilio
self.genero = genero
self.tipo_documento = tipo_documento
self.numero = numero
self.telefono = telefono
class Docente_responsable_taller(db.Model):
__tablename__ = 'docente_responsable_taller'
__table_args__ = (
PrimaryKeyConstraint('docente_id', 'ciclo_lectivo_id','taller_id'),
)
docente_id = db.Column(db.Integer, ForeignKey(Docente.id))
ciclo_lectivo_id = db.Column(db.Integer, ForeignKey(Ciclo_lectivo.id))
taller_id = db.Column(db.Integer, ForeignKey(Taller.id))
#Alta
def create(do,ci,ta):
elemento = Docente_responsable_taller (docente_id=do, ciclo_lectivo_id=ci, taller_id=ta)
db.session.add (elemento)
db.session.commit()
return elemento
#Read (devuelve todo)
def all():
return Docente_responsable_taller.query.all()
def setNucleo(do, ci, ta, nid):
e = Docente_responsable_taller.query.filter_by(docente_id=do, ciclo_lectivo_id=ci, taller_id=ta).first()
e.nucleo_id = nid
db.session.commit()
return e
def get(do, ci, ta):
return Docente_responsable_taller.query.filter_by(docente_id=do, ciclo_lectivo_id=ci, taller_id=ta).first()
class Ciclo_lectivo_taller(db.Model):
__tablename__ = 'ciclo_lectivo_taller'
__table_args__ = (PrimaryKeyConstraint('taller_id', 'ciclo_lectivo_id'), )
taller_id = db.Column(db.Integer, ForeignKey(Taller.id))
ciclo_lectivo_id = db.Column(db.Integer, ForeignKey(Ciclo_lectivo.id))
#Para añadir anexo entre taller y ciclo lectivo. Se hace con los id's de taller y ciclo.
def create(ta, ci):
elemento = Ciclo_lectivo_taller(taller_id=ta, ciclo_lectivo_id=ci)
db.session.add(elemento)
db.session.commit()
return elemento
#Read (devuelve todo)
def all():
return Ciclo_lectivo_taller.query.all()
def delete(tid, cid):
elemento = Ciclo_lectivo_taller.query.filter_by(
taller_id=tid, ciclo_lectivo_id=cid).first()
db.session.delete(elemento)
db.session.commit()
def get(tid, cid):
return Ciclo_lectivo_taller.query.filter_by(
taller_id=tid, ciclo_lectivo_id=cid).first()
class Taller(db.Model):
__tablename__ = 'taller'
id = db.Column(db.Integer, primary_key=True)
nombre = db.Column(db.String)
nombre_corto = db.Column(db.String)
def create(no, nocor):
elemento = Taller(nombre=no, nombre_corto=nocor)
db.session.add(elemento)
db.session.commit()
return elemento
def get_by_nombre(nom):
return Taller.query.filter_by(nombre=nom).first()
def all():
return Taller.query.all()
def get(id):
return Taller.query.filter_by(id=id).first()
def serialize(self):
return {
'id': self.id,
'nombre': self.nombre,
'nombre_corto': self.nombre_corto,
}
class User_tiene_rol(db.Model):
__tablename__ = 'usuario_tiene_rol'
__table_args__ = (
PrimaryKeyConstraint('usuario_id', 'rol_id'),
)
usuario_id = db.Column(db.Integer, ForeignKey(User.id))
rol_id = db.Column(db.Integer, ForeignKey(Rol.id))
def asignar_rol(idusuario, idrol):
#agrega tupla a la tabla
if not User_tiene_rol.query.filter_by(usuario_id=idusuario, rol_id=idrol).first():
elemento = User_tiene_rol (usuario_id = idusuario, rol_id = idrol)
db.session.add (elemento)
db.session.commit()
return True
def desasignar_rol(uid, rid):
#borra tupla de la tabla
if User_tiene_rol.query.filter_by(usuario_id=uid, rol_id=rid).first():
User_tiene_rol.query.filter_by(usuario_id=uid, rol_id=rid).delete()
db.session.commit()
return True
# El siguiente método se usa con los id's, para ello cada clase tiene un método por el cual
# pueden obtenerse.
def tiene_rol(uid, rid): #ESTE METODO PUEDE USARSE PARA SABER SI EL USUARIO EN CUESTIÓN, TIENE UN DETERMINADO ROL, VALIDAR EL RESULTADO CON NULO EN EL CONTROLADOR (comparar con none)
return User_tiene_rol.query.filter_by(usuario_id=uid, rol_id=rid).first()
class Nivel(db.Model):
__tablename__ = "nivel"
id = db.Column(db.Integer, primary_key=True)
nombre = db.Column(db.String(255), nullable=False, unique=True)
def __init__(self, nombre):
self.nombre = nombre
class TipoInstrumento(db.Model):
__tablename__ = "tipo_instrumento"
id = db.Column(db.Integer, primary_key=True)
nombre = db.Column(db.String(255), nullable=False, unique=True)
def __init__(self, nombre):
self.nombre = nombre
class Rol(db.Model):
__tablename__ = "rol"
id = db.Column(db.Integer, primary_key=True)
nombre = db.Column(db.String(255), nullable=False)
permisos = db.relationship("Permiso",
secondary=rol_tiene_permiso,
lazy='subquery')
class Escuela(db.Model):
__tablename__ = "escuela"
id = db.Column(db.Integer, primary_key=True)
nombre = db.Column(db.String(255), nullable=False, unique=True)
direccion = db.Column(db.String(255), nullable=False)
telefono = db.Column(db.String(255), nullable=False, unique=True)
def __init__(self, nombre, direccion, telefono):
self.nombre = nombre
self.direccion = direccion
self.telefono = telefono
class Escuela(db.Model):
__tablename__ = 'escuela'
id = db.Column(db.Integer, primary_key=True)
nombre = db.Column(db.String)
direccion = db.Column(db.String)
telefono = db.Column(db.String)
def get_all():
return Escuela.query.all()
def get_by_id(id):
return Escuela.query.get(id)
class Permiso(db.Model):
__tablename__ = 'permiso'
id = db.Column(db.Integer, primary_key=True)
nombre = db.Column(db.String)
#Este método sirve para obtener el id de un permiso específico.
def get_id(nombre_permiso):
return Permiso.query.filter_by(nombre=nombre_permiso).first()
def all():
return Permiso.query.all()
class Rol(db.Model):
__tablename__ = 'rol'
id = db.Column(db.Integer, primary_key=True)
nombre = db.Column(db.String)
#Este método sirve para obtener el id de un rol específico.
def get_by_nombre(nombre_rol):
return Rol.query.filter_by(nombre=nombre_rol).first()
def all():
return Rol.query.all()
class Taller(db.Model):
__tablename__ = "taller"
id = db.Column(db.Integer, primary_key=True)
nombre = db.Column(db.String(255), nullable=False, unique=True)
nombre_corto = db.Column(db.String(255), nullable=False)
ciclos_lectivos = db.relationship("CicloLectivo",
secondary=ciclo_lectivo_taller,
lazy='subquery')
def __init__(self, nombre, nombre_corto):
self.nombre = nombre
self.nombre_corto = nombre_corto
class Nucleo(db.Model):
__tablename__ = 'nucleo'
id = db.Column(db.Integer, primary_key=True)
nombre = db.Column(db.String)
def get_all():
return Nucleo.query.all()
def get_by_nombre(nombre_nucleo):
return Nucleo.query.filter_by(nombre=nombre_nucleo).first()
def get_by_id(unid):
return Nucleo.query.filter_by(id=unid).first()
class Nucleo(db.Model):
__tablename__ = "nucleo"
id = db.Column(db.Integer, primary_key=True)
nombre = db.Column(db.String(255), nullable=False, unique=True)
direccion = db.Column(db.String(255), nullable=False)
telefono = db.Column(db.String(255), nullable=False)
preceptores = db.relationship(Preceptor,
secondary=preceptor_nucleo,
lazy='subquery')
def __init__(self, nombre, direccion, telefono):
self.nombre = nombre
self.direccion = direccion
self.telefono = telefono
class Preceptor(db.Model):
__tablename__ = "preceptor"
id = db.Column(db.Integer, primary_key=True)
apellido = db.Column(db.String(255), nullable=False)
nombre = db.Column(db.String(255), nullable=False)
tel = db.Column(db.String(255), nullable=False, unique=True)
nucleos = db.relationship("Nucleo",
secondary=preceptor_nucleo,
lazy='subquery')
def __init__(self, apellido, nombre, telefono):
self.apellido = apellido
self.nombre = nombre
self.telefono = telefono
class rol_tiene_permiso(db.Model):
__tablename__ = 'rol_tiene_permiso'
__table_args__ = (PrimaryKeyConstraint('id_rol', 'id_permiso'), )
id_rol = db.Column(db.Integer, ForeignKey(Rol.id))
id_permiso = db.Column(db.Integer, ForeignKey(Permiso.id))
# Con este método, se sabe si un rol tiene un permiso específico. Se debe utilizar pasándole los id de ambas cosas
# (para ello ambas clases poseen un método para averiguarlo)
def tiene_permiso(idrol, idpermiso):
return Permiso.query.filter_by(id_rol=idrol,
id_permiso=idpermiso).first()
def all():
return rol_tiene_permiso.query.all()
class HorarioTaller(db.Model):
__tablename__ = "horario_taller"
id = db.Column(db.Integer, primary_key=True)
ciclo_lectivo_id = db.Column(db.Integer, db.ForeignKey('ciclo_lectivo.id'))
ciclo_lectivo = db.relationship(CicloLectivo, uselist=False)
taller_id = db.Column(db.Integer, db.ForeignKey('taller.id'))
taller = db.relationship(Taller, uselist=False)
nucleo_id = db.Column(db.Integer, db.ForeignKey('nucleo.id'))
nucleo = db.relationship("Nucleo", uselist=False)
dia_semana = db.Column(db.String, nullable=False)
hora_inicio = db.Column(db.String, nullable=False)
hora_fin = db.Column(db.String, nullable=False)
def __init__(self, nucleo_id, ciclo_lectivo_id, taller_id, dia_semana,
hora_inicio, hora_fin):
self.nucleo_id = nucleo_id
self.ciclo_lectivo_id = ciclo_lectivo_id
self.taller_id = taller_id
self.dia_semana = dia_semana
self.hora_inicio = hora_inicio
self.hora_fin = hora_fin
class CicloLectivo(db.Model):
__tablename__ = "ciclo_lectivo"
id = db.Column(db.Integer, primary_key=True)
fecha_ini = db.Column(db.DateTime, nullable=False)
fecha_fin = db.Column(db.DateTime, nullable=False)
semestre = db.Column(db.Integer, nullable=False)
talleres = db.relationship("Taller",
secondary=ciclo_lectivo_taller,
lazy='subquery')
# asistencia_estudiante_taller = db.relationship("AsistenciaEstudianteTaller", secondary=asistencia_estudiante_taller, lazy='subquery')
# asistencia_estudiante_taller = db.relationship("AsistenciaEstudianteTaller", back_populates="ciclo_lectivo")
def __init__(self, fecha_ini, fecha_fin, semestre):
self.fecha_ini = fecha_ini
self.fecha_fin = fecha_fin
self.semestre = semestre
class Instrumento(db.Model):
__tablename__ = "instrumento"
numero_inventario = db.Column(db.Integer, primary_key=True)
nombre = db.Column(db.String(255), nullable=False, unique=True)
tipo_instrumento_id = db.Column(db.Integer,
db.ForeignKey('tipo_instrumento.id'))
tipo_instrumento = db.relationship(TipoInstrumento,
backref=backref(
'instrumento_tipo_instrumento',
uselist=True,
cascade='delete,all'))
ruta_imagen = db.Column(db.String(255))
def __init__(self, nombre, tipo_instrumento_id, ruta_imagen):
self.nombre = nombre
self.tipo_instrumento_id = tipo_instrumento_id
self.ruta_imagen = ruta_imagen
class EstudianteTaller(db.Model):
__tablename__ = "estudiante_taller"
id = db.Column(db.Integer, primary_key=True)
estudiante_id = db.Column(db.Integer, db.ForeignKey("estudiante.id"))
estudiante = db.relationship("Estudiante")
# ciclo_lectivo_id = db.Column(db.Integer, db.ForeignKey("ciclo_lectivo.id"), primary_key=True)
# ciclo_lectivo = db.relationship("CicloLectivo")
#
# taller_id = db.Column(db.Integer, db.ForeignKey("taller.id"), primary_key=True)
# taller = db.relationship("Taller")
horario_id = db.Column(db.Integer, db.ForeignKey("horario_taller.id"))
horario = db.relationship("HorarioTaller")
def __init__(self, estudiante_id, horario_id):
self.estudiante_id = estudiante_id
self.horario_id = horario_id
class AsistenciaEstudianteTaller(db.Model):
__tablename__ = "asistencia_estudiante_taller"
id = db.Column(db.Integer, primary_key=True)
estudiante_id = db.Column(db.Integer, db.ForeignKey('estudiante.id'))
estudiante = db.relationship(Estudiante, backref = backref('asistencia_estudiante_taller_estudiante', uselist = True, cascade = 'delete,all'))
ciclo_lectivo_id = db.Column(db.Integer, db.ForeignKey('ciclo_lectivo.id'))
ciclo_lectivo = db.relationship(CicloLectivo, backref = backref('asistencia_estudiante_taller_ciclo_lectivo', uselist = True, cascade = 'delete,all'))
taller_id = db.Column(db.Integer, db.ForeignKey('taller.id'))
taller = db.relationship(Taller, backref = backref("asistencia_estudiante_taller_taller", uselist = True, cascade = 'delete,all'))
fecha = db.Column(db.DateTime, nullable=False)
def __init__(self, estudiante_id, ciclo_lectivo_id, taller_id, fecha):
self.estudiante_id = estudiante_id
self.ciclo_lectivo_id = ciclo_lectivo_id
self.taller_id = taller_id
self.fecha = fecha
class DocenteResponsableTaller(db.Model):
__tablename__ = "docente_responsable_taller"
docente_id = db.Column(db.Integer,
db.ForeignKey("docente.id"),
primary_key=True)
docente = db.relationship("Docente")
ciclo_lectivo_id = db.Column(db.Integer,
db.ForeignKey("ciclo_lectivo.id"),
primary_key=True)
ciclo_lectivo = db.relationship("CicloLectivo")
taller_id = db.Column(db.Integer,
db.ForeignKey("taller.id"),
primary_key=True)
taller = db.relationship("Taller")
def __init__(self, docente_id, ciclo_lectivo_id, taller_id):
self.docente_id = docente_id
self.ciclo_lectivo_id = ciclo_lectivo_id
self.taller_id = taller_id
class Responsable_Estudiante(db.Model):
__tablename__ = 'responsable_estudiante'
__table_args__ = (PrimaryKeyConstraint('responsable_id',
'estudiante_id'), {
'extend_existing': True
})
responsable_id = db.Column(db.Integer,
ForeignKey(responsable.Responsable.id))
estudiante_id = db.Column(db.Integer, ForeignKey(estudiante.Estudiante.id))
def all():
return Responsable_Estudiante.query.all()
def get(rid, eid):
return Responsable_Estudiante.query.filter_by(
responsable_id=rid, estudiante_id=eid).first()
def create(rid, eid):
e = Responsable_Estudiante(responsable_id=rid, estudiante_id=eid)
db.session.add(e)
db.session.commit()
return e
class Estudiante_taller(db.Model):
__tablename__ = 'estudiante_taller'
__table_args__ = (
PrimaryKeyConstraint('estudiante_id', 'ciclo_lectivo_id','taller_id'),
)
estudiante_id = db.Column(db.Integer, ForeignKey(estudiante.Estudiante.id))
ciclo_lectivo_id = db.Column(db.Integer, ForeignKey(ciclo_lectivo.Ciclo_lectivo.id))
taller_id = db.Column(db.Integer, ForeignKey(taller.Taller.id))
#Alta
def create(es,ci,ta):
elemento = Estudiante_taller (estudiante_id=es, ciclo_lectivo_id=ci, taller_id=ta)
db.session.add (elemento)
db.session.commit()
return elemento
#Read (devuelve todo)
def all():
return Estudiante_taller.query.all()
def get(eid, cid, taid):
return Estudiante_taller.query.filter_by(estudiante_id=eid, ciclo_lectivo_id=cid, taller_id=taid).first()
class Usuario(db.Model):
__tablename__ = "usuario"
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(255), nullable=False, unique=True)
username = db.Column(db.String(255), nullable=False, unique=True)
password = db.Column(db.String(255), nullable=False)
activo = db.Column(db.Boolean, nullable=False)
updated_at = db.Column(db.DateTime)
created_at = db.Column(db.DateTime, nullable=False)
first_name = db.Column(db.String(255), nullable=False)
last_name = db.Column(db.String(255), nullable=False)
roles = db.relationship("Rol",
secondary=usuario_tiene_rol,
lazy="subquery")
def __init__(self, email, username, password, first_name, last_name):
self.email = email
self.username = username
self.password = password
self.activo = True
self.created_at = datetime.datetime.now()
self.first_name = first_name
self.last_name = last_name
class configuracion(db.Model):
__tablename__ = 'configuracion'
id = db.Column(db.Integer, primary_key=True)
titulo = db.Column(db.String)
descripcion = db.Column(db.String)
mail = db.Column(db.String)
cantListar = db.Column(db.Integer)
sitio_habilitado = db.Column(db.Integer)
#Consultas para actualización
def set_titulo(title):
obj = configuracion.query.filter_by(id=1).first()
obj.titulo = title
db.session.commit()
return True
def set_descripcion(des):
obj = configuracion.query.filter_by(id=1).first()
obj.descripcion = des
db.session.commit()
return True
def set_mail(m):
obj = configuracion.query.filter_by(id=1).first()
obj.mail = m
db.session.commit()
return True
def set_cantListar(cant):
obj = configuracion.query.filter_by(id=1).first()
obj.cantListar = cant
db.session.commit()
return True
def set_habilitacion(valor):
# 1 para habilitado. 0 para deshabilitado.
obj = configuracion.query.filter_by(id=1).first()
obj.sitio_habilitado = valor
db.session.commit()
return True
def get_habilitacion():
return configuracion.query.filter_by(id=1).first()
#consulta para mostrar en pantalla todos los campos de id 1
def get_config():
return configuracion.query.filter_by(id=1).first()
