registro_escolar/escuela/prueba.py

#Comentar no es mi fuerte Gabriel Santiago
#Este file es 'viejo' estoy editando más cosas. Pero ye
#also los html's lo tengo en mi compu no los subo al git


from flask import Flask, render_template, request, redirect, jsonify

#flask_sqlalchemy es una excelente libreria para usar bases de datos
from flask_sqlalchemy import SQLAlchemy

import datetime, json

app = Flask(__name__)

#para sql segun lo que vi
#hay que instalar un pymysql despues tener un file con lo de User, password, host, db
#entonces then do something like

#connect = 'mysql+pymysql://dbuser:password@dbHost/dbName

#vi en sqlAlchemy documentation que no es necesario pymysql pero pymysql tiene cosas interesantes

#entonces aqui fuera app.config[lo que esta abajo] = connect

connect = 'mysql+pymysql://root@localhost/registro_escolar'

app.config['SQLALCHEMY_DATABASE_URI'] = connect

#aqui se crea el objeto db, utilizando el config de app

db = SQLAlchemy(app)

#aqui estan las clases que serian las tablas,
#por alguna razon tienes que crear las tablas que vayas a usar en python

#so like si creo una de maestros pues
#class Maestro(db.model):


#db.Column crea columna, el tipo de dato y tiene algunos features como primary_key, nullable, db.ForeignKey etc

class usuarios(db.Model):

    id = db.Column(db.Integer, primary_key=True, autoincrement =True)
    nombres = db.Column(db.String(100))
    apellidos = db.Column(db.String(100))
    email = db.Column(db.String(100))
    username = db.Column(db.String(100), nullable = True)
    password = db.Column(db.String(100), nullable = True)
    fecha_nacimiento = db.Column(db.DateTime, default = datetime.datetime.now())
    direccion1 = db.Column(db.String(200), default = 'En la casa de tu mai')
    direccion2 = db.Column(db.String(200), default = 'En la casa de tu pai tambien')
    ciudad = db.Column(db.String(100), default ='En la ciudad de los dioses')
    pais = db.Column(db.String(100), default = 'Tu Pai')
    zipcode = db.Column(db.String(100), default= 'cabron' )
    telefono1 = db.Column(db.String(16),default= 'cabron' )
    telefono2 = db.Column(db.String(20),default= 'cabron' )
    genero = db.Column(db.String(30),default= 'cabron' )
    

    def __repr__(self):
        return 'Usuario ' + str(self.id)
    

class cursos(db.Model):
    id = db.Column(db.Integer, primary_key=True, autoincrement = True)
    codigo = db.Column(db.String(12))
    titulo = db.Column(db.String(100))
    grado = db.Column(db.Integer)
    descripcion = db.Column(db.String(200))

    def __repr__(self):
        return 'Curso ' + str(self.id)

class facultad(db.Model):
    user_id = db.Column(db.Integer, db.ForeignKey(usuarios.id), primary_key=True)
    especialidad = db.Column(db.String(200))
    educacion_especial = db.Column(db.Integer)

class oferta(db.Model):
    id = db.Column(db.Integer, primary_key=True, autoincrement = True)
    oferta_id = db.Column(db.Integer, db.ForeignKey(cursos.id))
    semestre = db.Column(db.String(20))
    horario = db.Column(db.String(100))

class facultad_ofrece(db.Model):
    id = db.Column(db.Integer, primary_key=True, autoincrement = True)
    oferta_id = db.Column(db.Integer, db.ForeignKey(oferta.id))
    facultad_id = db.Column(db.Integer, db.ForeignKey(facultad.user_id))
    porciento = db.Column(db.Integer, default = 100)


    
    
class estudiantes(db.Model):
    user_id = db.Column(db.Integer, db.ForeignKey(usuarios.id), primary_key=True)
    grado = db.Column(db.Integer)
    educacion_especial = db.Column(db.String(30))

    def __repr__(self):
        return 'estudiante ' + str(self.user_id)

class matricula(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    estudiante_id = db.Column(db.Integer, db.ForeignKey(estudiantes.user_id))
    oferta_id = db.Column(db.Integer, db.ForeignKey(oferta.id))

class evaluaciones(db.Model):
    id = db.Column(db.Integer, primary_key =True, autoincrement = True)
    tipo = db.Column(db.String(100))
    valor = db.Column(db.Integer)
    fecha = db.Column(db.DateTime, default = datetime.datetime.now())
    oferta_id = db.Column(db.Integer, db.ForeignKey(oferta.id))

class asistencia(db.Model):
    id = db.Column(db.Integer, primary_key = True, autoincrement = True)
    matricula_id = db.Column(db.Integer, db.ForeignKey(matricula.id))
    fecha = db.Column(db.DateTime, default = datetime.datetime.now())
    valor = db.Column(db.Integer)
class notas(db.Model):
    id = db.Column(db.Integer)
    evaluacion_id = db.Column(db.Integer, db.ForeignKey(evaluaciones.id), primary_key=True)
    estudiante_id = db.Column(db.Integer, db.ForeignKey(estudiantes.user_id), primary_key=True)
    valor = db.Column(db.Integer)

    def __repr__(self):
        return 'nota '  +str(self.id)
    
#Para ver los botones

@app.route('/')

def helloWorld():
    return render_template('index.html')

#Este código es para añadir clases

@app.route('/addClass', methods=['GET', 'POST'])
def addClass():
    if request.method == 'POST':

        post_codigo = request.form['codigo']
        post_titulo = request.form['titulo']
        post_grado = request.form['grado']
        post_descripcion = request.form['descripcion']

        curso_nuevo = cursos(codigo =post_codigo, titulo=post_titulo, grado = post_grado, descripcion=post_descripcion)

        db.session.add(curso_nuevo)
        db.session.commit()
        return redirect('/addClass')
    else:
        return render_template('addClases.html')

#beta, felt cute in this pic might delete later
#add notas 

@app.route ('/add', methods=['GET','POST'])
def addSomething():
    
    if request.method =='POST':
        
        post_nombre = request.form['nombre']
        post_nota = request.form['Nota']
        

        nota_nueva = Notas(nombre=post_nota, valor = post_nota)
        
        

        db.session.add(nota_nueva)
        db.session.commit()
        return redirect('/addNota')
    else:
        return render_template('addSomething.html')

#Este pedazo acepta ofertas, 

@app.route('/addOferta', methods =['GET', 'POST'])
def addOferta():
    
    if request.method =='POST':
        post_oferta_id = int(request.form['curso'])
        post_academico = request.form['academico']
        post_horario = request.form['horario']

        ofertaNueva = oferta(oferta_id =post_oferta_id, semestre = post_academico, horario =post_horario)

        db.session.add(ofertaNueva)
        db.session.commit()

        oferta_idQue = oferta.query.order_by(oferta.id.desc()).first().id

        count = int(request.form['countRow'])

        #Despues de oferta, añadir lo de facultad, permite más de un maestro
        for x in range(count):
            post_maestro = int(request.form['Maestro[{}]'.format(x)])

            maestro_oferta= facultad_ofrece(oferta_id =oferta_idQue, facultad_id =post_maestro)
            db.session.add(maestro_oferta)
            db.session.commit()
            
        return redirect('/addOferta')
        
    else:
        cursosAll = cursos.query.all()
        maestrosAll = db.engine.execute('SELECT * FROM `facultad` f, `usuarios` u where f.user_id = u.id')
        ofertaAll = db.engine.execute('SELECT  o.semestre, o.horario, f.oferta_id, count(f.facultad_id) cantidadMaestros, f.oferta_id, c.codigo, c.titulo, c.grado FROM `oferta` o, `cursos` c, `facultad_ofrece` f where o.curso_id =c.id and f.oferta_id = o.id group by f.oferta_id')
        
        return render_template('addOferta.html', cursos= cursosAll, maestros= maestrosAll, ofertas = ofertaAll)



#Add oferta a los estudiantes, matricularlos

@app.route ('/addMatricula/<int:oferId>', methods =['GET', 'POST'])
def addMatricula(oferId):
    if request.method =='POST':
        count = int(request.form['countRow'])

        for x in range(count):
            post_estudiante = int(request.form['estudiantes[{}]'.format(x)])

            matriculaNueva = matricula(estudiante_id = post_estudiante, oferta_id=oferId)
            db.session.add(matriculaNueva)
            db.session.commit()

        return redirect('/addMatricula/{}'.format(oferId))


    
    
    else:
        matriculadosAll = db.engine.execute('SELECT u.nombres, u.apellidos FROM `usuarios` u, `matricula` m where m.oferta_id ={} and m.estudiante_id = u.id ORDER BY u.apellidos'.format(oferId))
        estudiantesAll = db.engine.execute('SELECT u.apellidos, u.nombres, e.user_id FROM `usuarios` u, `estudiantes` e where u.id = e.user_id ORDER BY u.apellidos' )
        return render_template('addMatricula.html', estudiantes = estudiantesAll, oferId=oferId, matriculados = matriculadosAll)


#############################################33333
#
#
#     MAESTRO DASHBOARD
#
#
#
##################################################33
@app.route('/Maestro/<int:MaestroId>')
def Maestro(MaestroId):
    cursosTodos = db.engine.execute('select c.codigo, o.horario, c.titulo, f.oferta_id from `oferta` o, `cursos` c, `facultad_ofrece` f where f.oferta_id = o.id and f.facultad_id = {} and o.curso_id =c.id'.format(MaestroId))
    fecha = datetime.date.today()
    return render_template('dashboard.html', MaestroId = MaestroId, los_cursos = cursosTodos, fecha = fecha)



#@app.route('/Maestro/<int:MaestroId>/<int:ofertaId>')
#def cursosPagina(MaestroId, ofertaId):
    
#    newCourses = cursos.query.filter_by(id=ofertaId).first()
#    return render_template('cursos.html',MaestroId = MaestroId, id=ofertaId, el_curso=newCourses)

#Add estudiantes

######################################
#
#
#
#   AñADIR EVALUACIONES 
#
#
#
######################################
@app.route('/Maestro/<int:MaestroId>/<int:ofertaId>/addNota', methods =['GET','POST'])
def addNota(MaestroId, ofertaId):


    if request.method =='POST':

        post_ofertaId = ofertaId

        #Editar es una variable que contiene, añadir, borrar, o el id de la evaluacion para update

        if request.get_json()['editar'] == 'Añadir':
            post_tipo = request.get_json()['tipo']
            post_valor = int(request.get_json()['valor'])
            post_fecha = request.get_json()['Fecha']
            
           


            newEval = evaluaciones(oferta_id=post_ofertaId, tipo=post_tipo, valor = post_valor, fecha =datetime.date(int(post_fecha[0]),int(post_fecha[1]),int(post_fecha[2])))

            db.session.add(newEval)
            db.session.commit()
            

        elif request.get_json()['editar'] == 'Borrar':
            db.session.execute('DELETE from `evaluaciones` where id = {}'.format(int(request.get_json()['tipo'])))
      
        else:
           
            post_tipo = request.get_json()['tipo']
            post_valor = int(request.get_json()['valor'])
            post_fecha = request.get_json()['Fecha'] 
            post_id = int(request.get_json()['editar'])
        
            db.session.execute('UPDATE `evaluaciones` SET tipo ="{}", valor ={}, fecha = "{}" where id = {}'.format(post_tipo, post_valor, post_fecha, post_id))
            db.session.commit()
            
        
           
        return redirect('/Maestro/'+ str(MaestroId) + '/'+str(ofertaId)+'/addNota')

    else:

        #creo un diccionario para poder crear un json y utilizarlo en jquery 
        #and llenar html y llenar la tabla dinamico
        
        

        newCourses = cursos.query.filter_by(id=ofertaId).first()
        allEval = evaluaciones.query.filter_by(oferta_id=ofertaId).all()
        bigList ={}

        for evaluacion in allEval:
            bigList.setdefault(int(evaluacion.id), {})['Valor'] =int(evaluacion.valor)
           
            bigList[evaluacion.id]['evalId'] = int(evaluacion.id)
            bigList[evaluacion.id]['tipo'] = evaluacion.tipo
            bigList[evaluacion.id]['fecha'] = str(evaluacion.fecha)
           

        return render_template('addEvaluacion.html',MaestroId = MaestroId, el_curso=ofertaId, evaluaciones = bigList)

#Añadir las notas de forma dinámicas

@app.route('/Maestro/<int:MaestroId>/<int:ofertaId>/addNotas', methods = ['GET','POST'])
def notas1(MaestroId, ofertaId):

    
    query = db.engine.execute('SELECT usuarios.id, usuarios.nombres, usuarios.apellidos from `notas`, `usuarios`, `evaluaciones` where evaluaciones.id = notas.evaluacion_id and notas.estudiante_id = usuarios.id and evaluaciones.oferta_id={}  group by usuarios.id order by usuarios.apellidos'.format(ofertaId))
    
    
    
    notasCompletaJson ={}

    query2 = db.engine.execute('SELECT id FROM `evaluaciones` where oferta_id = {}'.format(ofertaId))

    evalIds =[]
    
    for Id in query2:
        evalIds.append(int(Id.id))

    #loop para cada estudiante, pongo la nota que sacaron en cada evaluacion
    #estilo evaluaciones = ['evalId1', 'evalid2']
    #       notasSaco = ['evalId1-cuantoSaco', 'evalId2-cuantoSaco']
    # en el mismo orden
    
    for estudiante in query:
        Evaluaciones =[]
        notasSaco = []
        notasQuery = db.engine.execute('SELECT notas.valor Saco, notas.estudiante_id, notas.evaluacion_id, evaluaciones.valor ValorReal from `notas`, `usuarios`, `evaluaciones` where evaluaciones.id = notas.evaluacion_id and notas.estudiante_id = usuarios.id and evaluaciones.oferta_id={}  order by usuarios.apellidos, evaluaciones.id'.format(ofertaId))
    
        for nota in notasQuery:
            if nota.estudiante_id == estudiante.id:

                Evaluaciones.append(nota.evaluacion_id)
                notasSaco.append(nota.Saco)

    #aqui termino creando el diccionario twoDimensional estilo
    #{estudianteId: {
    #                   nombre:
    #                   apellidos:
    #                   valorSaco:[] 
    #                   evaluacion:[]
    # }
    # estudianteId2 : } ese estilo
    #   
        notasCompletaJson.setdefault(estudiante.id, {})['nombre'] = estudiante.nombres
        notasCompletaJson[estudiante.id]['apellidos'] = estudiante.apellidos
        notasCompletaJson[estudiante.id]['valorSaco'] = notasSaco
        notasCompletaJson[estudiante.id]['evaluacion'] = Evaluaciones

    


            
    if request.method =="POST":
        #recibe dinamicamente desde el javascript la posicion exacta del estudiante, que id y eso
        #utilizando jquery, vea addNotas.html para más info

        post_stuId = int(request.get_json()['StudentId'])
        post_nota = int(request.get_json()['Nota'])

        post_id = int(request.get_json()['evalId'])

        Exists = notas.query.filter_by(estudiante_id=post_stuId, evaluacion_id=post_id).first()

        #si existe la nota, hazle update a la tabla, else añadela

        if(Exists):
        
            query =db.engine.execute('UPDATE `notas` SET valor ={} WHERE estudiante_id ={} and evaluacion_id={}'.format(post_nota, post_stuId, post_id))
        
        else:
            notaNueva = notas(evaluacion_id = post_id, estudiante_id=post_stuId, valor =post_nota)
            db.session.add(notaNueva)
        
        db.session.commit()
        #for x in range(int(post_filas)):

        #    post_student = request.form['id_usuario[{}]'.format(x)]
            

        #    for y in range(int(post_columnas)):
        #        post_valor = request.form['evaluacion[{}][{}]'.format(x, y)]
        #        post_evaluacionId =request.form['cantidadEval[{}]'.format(y)]


        #        notaNueva = notas( evaluacion_id=post_evaluacionId, estudiante_id=post_student, valor = post_valor)

        #        db.session.add(notaNueva)
        #        db.session.commit()

        return redirect('/Maestro/'+str(MaestroId) +'/' + str(ofertaId)+'/addNota')


    else:
        evaluacionesTodos = db.engine.execute('select * from `evaluaciones` where oferta_id ={}'.format(ofertaId))
        estudiantes_Todos = db.engine.execute('select u.apellidos, u.nombres, u.id from `usuarios` u, `matricula` m where m.estudiante_id = u.id and m.oferta_id ={}'.format(ofertaId))
        

        return render_template('addNotas.html',MaestroId = MaestroId, evaluaciones = evaluacionesTodos, estudiantes=estudiantes_Todos, ofertaId = ofertaId, notasCompletas = notasCompletaJson, evalIds=evalIds)
    

#crea cuenta para estudiante o maestro, no importante

@app.route ('/estudiante', methods=['GET','POST'])
def addStudent():
    if request.method == 'POST':
        #acentos = {'á':'&aacute;', 'é': '&eacute;', 'í':'&iacute;', 'ó': '&oacute;', 'ú':'&uacute;',
        #'ü':'&uuml;', 'Á': '&Aacute;', 'É': '&Eacute;', 'Í':'&Iacute;', 'Ó':'&Oacute;', 'Ú':'&Uacute',
        #'Ü':'&Uuml;', 'Ñ':'&Ntilde'}
        
        post_apellidos = request.form['apellidos'] 
        post_nombre = request.form['nombre']
        post_email = request.form['email']
        estudiante_nuevo = usuarios(email=post_email, nombres=post_nombre, apellidos=post_apellidos)
        db.session.add(estudiante_nuevo)
        db.session.commit()

        last_id= usuarios.query.order_by(usuarios.id.desc()).first().id
        
        if(request.form['Usuario'] == 'Estudiante'):
            post_grado = request.form['grado']
            post_educ = request.form['educ']

        #for key in acentos.keys():
        #    post_apellidos= post_apellidos.replace(key,acentos[key])
        #    post_nombre = post_nombre.replace(key,acentos[key])
        

            estudiante_nuevo = estudiantes(user_id=last_id, grado = post_grado, educacion_especial=post_educ)
            db.session.add(estudiante_nuevo)
            db.session.commit()
        
        else:
            post_especialidad = request.form['especialidad']
            maestro_nuevo = facultad(user_id = last_id, especialidad= post_especialidad, educacion_especial =0)
            db.session.add(maestro_nuevo)
            db.session.commit()




        #last_id= 8.query.order_by(usuarios.id.desc()).first()
        #db.session.add(estudiantes(user_id =last_id, grado=post_grado, educacion_especial =post_educ))
        #db.session.commit()
        return redirect('/estudiante')
    else:
        return render_template('estudiante.html')




#NO ES IMPORTANTE, se puede borrar, quiere ver notas, pero se puede hacer en añadir notas

@app.route('/Maestro/<int:MaestroId>/<int:ofertaId>/verNotas')
def cursosVerNotas(MaestroId, ofertaId):

    evaluacionesTodas = evaluaciones.query.filter_by(oferta_id=ofertaId).all()
    cursosTodos = cursos.query.filter_by(id=ofertaId).all()

    return render_template('verNotas.html', MaestroId = MaestroId, cursos=cursosTodos, evaluaciones=evaluacionesTodas)

@app.route("/Maestro/<int:MaestroId>/<int:evalId>/verNotasEstudiantes")
def verNotasEstudiantes(MaestroId, evalId):

    result = db.engine.execute('SELECT * FROM `notas` n, `usuarios` where n.evaluacion_id ={} and usuarios.id = n.estudiante_id'.format(evalId))

    
    
    #db.session.query(evaluacion, usuarios).join(Usuarios).filter(usuarios.id == evaluacion.estudiante_id).order_by(usuarios.apellidos)

    return render_template('verNotasEstudiantes.html',table=result, MaestroId = MaestroId, evalId=evalId)


#Añadir la asistencia de los estudiantes.
#recibe la info dinamicamente como addNotas
#El mismo estilo que el de añadir notas, solo que la fecha, cuando cambia, reloads y busca 
#la asistencia de ese día

@app.route("/Maestro/<int:MaestroId>/<int:ofertaId>/addAsistencia/<string:fecha>", methods = ['POST', 'GET'])
def pasarAsistencia(MaestroId, ofertaId, fecha):
    if request.method =='POST':

        post_Asistencia = int(request.get_json()['Asistencia'])
        post_Matricula = int(request.get_json()['Matricula'])
        post_Fecha = request.get_json()['Fecha']
        post_Fecha = post_Fecha.split('-')
        
        post_Fecha = datetime.date(int(post_Fecha[0]),int(post_Fecha[1]),int(post_Fecha[2]))


        Exists = asistencia.query.filter_by(fecha = post_Fecha, matricula_id = post_Matricula).first()

        #si existe, update, sino, crea

        if (Exists!=None):
            query = db.engine.execute('UPDATE `asistencia` SET valor = {} WHERE fecha = "{}" and matricula_id = {}'.format(post_Asistencia, post_Fecha, post_Matricula))
            print('aqui')
            db.session.commit()

        else:
            asistenciaNueva = asistencia(fecha = post_Fecha, matricula_id = post_Matricula, valor = post_Asistencia)

            db.session.add(asistenciaNueva)
            db.session.commit()
        return redirect("/Maestro/{}/{}/addAsistencia/{}".format(MaestroId, ofertaId, post_Fecha))


#aqui creo un diccionario para json, y poder poner checked a la asistencia, 
#si la asistencia existe pues la pone checked

    elif request.method =='GET':
        
        
        estudiantes_Todos =  db.engine.execute('select u.apellidos, u.nombres, m.id matricula, u.id from `usuarios` u, `matricula` m where m.estudiante_id = u.id and m.oferta_id ={} order by u.apellidos'.format(ofertaId))
        matriculaAsis = db.engine.execute('select fecha, matricula_id, valor from asistencia, (select m.id from `usuarios` u, `matricula` m where m.estudiante_id = u.id and m.oferta_id ={} order by u.apellidos) t where t.id = matricula_id and fecha = "{}"'.format(ofertaId, fecha))
        dictList = {}
        for matri in matriculaAsis:
            
            dictList.setdefault(matri.matricula_id,{})['Asistencia']= matri.valor
        
   
    
        return render_template('Asistencia.html', MaestroId = MaestroId, estudiantes = estudiantes_Todos, ofertaId=ofertaId, fecha = fecha, dictList =dictList)


#############################
#
#ESTUDIANTES
#
#############################

@app.route('/dashEstudiantes/<int:estId>')
def dashEstudiantes(estId):
    nombre = usuarios.query.filter_by(id=estId).first()
    
    return render_template('dashEstudiantes.html',nombre=nombre.nombres, estId=estId)


#enseña las notas y la asistencia que tiene en ese curso

@app.route('/dashEstudiantes/<int:estId>/notas')
def dashEstNotas(estId):
    cursosMatri = cursos.query.all()
    
    resultEstudiante = db.engine.execute('SELECT sum(evaluaciones.valor) valorReal, sum(notas.valor) valorSaco, cursos.codigo, cursos.titulo, evaluaciones.oferta_id, matricula.estudiante_id FROM `cursos`, `matricula`, `oferta`, `notas`, `evaluaciones` where matricula.estudiante_id={} and evaluaciones.id=notas.evaluacion_id and matricula.estudiante_id=notas.estudiante_id and evaluaciones.oferta_id = oferta.id and matricula.oferta_id = evaluaciones.oferta_id and cursos.id = oferta.curso_id group by matricula.oferta_id'.format(estId))
    nombre = usuarios.query.filter_by(id=estId).first().nombres
    
    matriculaEstu = db.engine.execute ('select id, oferta_id from matricula  where estudiante_id ={}'.format(estId))
    ofertasConAsistencia ={}

    for matri in matriculaEstu:
        asistencia =db.engine.execute('select count(valor) asis from `asistencia` where matricula_id ={} and valor =0'.format(matri.id))
        asistencia = asistencia.fetchone()
        
        ofertasConAsistencia.setdefault(matri.oferta_id, {})['Presente']= int(asistencia.asis)
        
        asistencia =db.engine.execute('select count(valor) asis from `asistencia` where matricula_id ={} and valor =1'.format(matri.id))
        asistencia = asistencia.fetchone()

        ofertasConAsistencia[matri.oferta_id]['Tarde']= int(asistencia.asis)
        
        asistencia =db.engine.execute('select count(valor) asis from `asistencia` where matricula_id ={} and valor =2'.format(matri.id))
        asistencia = asistencia.fetchone()
        
        ofertasConAsistencia[matri.oferta_id]['Ausente']= int(asistencia.asis)
        
        asistencia = db.engine.execute('select count(valor) asis from `asistencia` where matricula_id ={} and valor =3'.format(matri.id))
        asistencia = asistencia.fetchone()
        
        ofertasConAsistencia[matri.oferta_id]['Excusado']= int(asistencia.asis)
    

    return render_template('estuNotas.html',nombre=nombre, todaNota = resultEstudiante, estId= estId, ofertasConAsistencia = ofertasConAsistencia)


@app.route('/dashEstudiantes/<int:estId>/notas/<int:ofertaId>')

def dashEstEval(estId, ofertaId):
    result = db.engine.execute('SELECT notas.valor valorSaco, evaluaciones.valor valorReal, evaluaciones.tipo from `evaluaciones`, `matricula`, `notas` where evaluaciones.oferta_id = {} and matricula.oferta_id = evaluaciones.oferta_id and matricula.estudiante_id={} and notas.estudiante_id=matricula.estudiante_id and notas.evaluacion_id = evaluaciones.id'.format(ofertaId, estId))
    nombre = usuarios.query.filter_by(id=estId).first().nombres
    return render_template('verEstuNotas.html',nombre=nombre, todo =result, estId=estId)


    
    






if __name__ == "__main__":
    app.run(debug=True)