def get(self):
args = self.reqparse.parse_args()
token = args.get('auth-token')
userAdmin = Administrador.load_from_token(token)
if userAdmin == None:
return {'response': 'user_invalid'}, 401
institucion = None
if userAdmin != None:
institucion = Institucion.objects(
id=userAdmin.institucion.id).first()
if institucion == None:
return {'response': 'colegio_invalid'}, 404
data = []
labels = []
for recurso in Curso.objects(institucion=institucion.id,
activo=True,
publicado=True).all():
labels.append(recurso.nombre)
aprobacion = 0
for evaluacion in Evaluacion.objects(curso=recurso.id).all():
aprobacion = aprobacion + evaluacion.acierto
if Evaluacion.objects(curso=recurso.id).count() != 0:
aprobacion = int(aprobacion /
Evaluacion.objects(curso=recurso.id).count())
data.append(aprobacion)
return {
"data": [{
"data": data,
"label": "Aprobación"
}],
"labels": labels
}
def get(self, id):
args = self.reqparse.parse_args()
token = args.get('auth-token')
alumno = Alumno.load_from_token(token)
apoderado = Apoderado.load_from_token(token)
administrador = Administrador.load_from_token(token)
profesor = Profesor.load_from_token(token)
if alumno == None and apoderado == None and administrador == None and profesor == None:
return {'response': 'user_invalid'}, 401
curso = Curso.objects(id=id).first()
labels = []
data = []
for asignatura in curso.asignaturas:
labels.append(asignatura.nombre)
suma_parcial_pruebas = 0
for prueba in Prueba.objects(asignatura=asignatura.id,
tipo="ENSAYO").all():
suma_parcial_evaluaciones = 0
for evaluacion in Evaluacion.objects(prueba=prueba.id).all():
print(evaluacion.alumno.curso)
if evaluacion.alumno.curso == curso:
suma_parcial_evaluaciones = suma_parcial_evaluaciones + evaluacion.puntaje
if Evaluacion.objects(prueba=prueba.id).count() > 0:
suma_parcial_evaluaciones = suma_parcial_evaluaciones / (
Evaluacion.objects(prueba=prueba.id).count())
suma_parcial_evaluaciones = int(suma_parcial_evaluaciones)
suma_parcial_pruebas = suma_parcial_pruebas + suma_parcial_evaluaciones
if Prueba.objects(asignatura=asignatura.id,
tipo="ENSAYO").count() > 0:
suma_parcial_pruebas = int(
suma_parcial_pruebas / (Prueba.objects(
asignatura=asignatura.id, tipo="ENSAYO").count()))
data.append(suma_parcial_pruebas)
return {"labels": labels, "data": data}
def actualizar_aprobacion(self):
from models.evaluacion import Evaluacion
promedio = 0
cantidad = Evaluacion.objects(curso=self.id).count()
for evaluacion in Evaluacion.objects(curso=self.id).all():
promedio = evaluacion.acierto + promedio
if cantidad>0:
promedio = int(promedio/cantidad)
self.aprobacion = promedio
def post(self, id):
args = self.reqparse.parse_args()
token = args.get('auth-token')
profesor = Profesor.load_from_token(token)
data = request.data.decode()
data = json.loads(data)
prueba = Prueba.objects(id=id).first()
for registro in data['data']:
evaluacion = Evaluacion()
cantidad_buenas = 0
cantidad_malas = 0
cantidad_omitidas = 0
alumno = Alumno.objects(id=registro['id']).first()
evaluacion.alumno = alumno
evaluacion.prueba = prueba
for pregunta in prueba.preguntas:
respuesta = Respuesta()
respuesta.numero_pregunta = pregunta.numero_pregunta
if registro[str(pregunta.numero_pregunta)] == "":
cantidad_omitidas = cantidad_omitidas + 1
respuesta.correcta = False
if prueba.tipo != "TAREA":
respuesta.alternativa = "O"
else:
if prueba.tipo != "TAREA":
if registro[str(pregunta.numero_pregunta)].upper(
) == pregunta.alternativa.upper():
cantidad_buenas = cantidad_buenas + 1
respuesta.correcta = True
respuesta.alternativa = str(registro[str(
pregunta.numero_pregunta)].upper())
else:
cantidad_malas = cantidad_malas + 1
respuesta.correcta = False
respuesta.alternativa = str(registro[str(
pregunta.numero_pregunta)].upper())
else:
if registro[str(pregunta.numero_pregunta)].upper(
) == "CORRECTA":
cantidad_buenas = cantidad_buenas + 1
respuesta.correcta = True
if registro[str(pregunta.numero_pregunta)].upper(
) == "INCORRECTA":
cantidad_malas = cantidad_malas + 1
respuesta.correcta = False
evaluacion.respuestas.append(respuesta)
evaluacion.cantidad_buenas = cantidad_buenas
evaluacion.cantidad_malas = cantidad_malas
evaluacion.cantidad_omitidas = cantidad_omitidas
evaluacion.puntaje = int((
(850 - prueba.puntaje_base) / len(prueba.preguntas)) *
cantidad_buenas + prueba.puntaje_base)
evaluacion.save()
return {'Response': 'exito'}
def put(self, id_recurso):
if not 'auth-token' in request.headers:
return {'response': 'no_token'}, 401
user = None
token = request.headers.get('auth_token')
user = Alumno.load_from_token(token)
if user == None:
return {'response': 'user_invalid'}, 401
curso = Curso.objects(id=id_recurso).first()
if curso == None:
return {'response': 'resource_invalid'}, 404
data = request.data.decode()
data = json.loads(data)
alumno = user
if not 'respuestas' in data or len(data['respuestas']) == 0:
return {'response': 'invalid_data'}, 404
respuestas = data['respuestas']
evaluacion = Evaluacion()
evaluacion.alumno = alumno.id
evaluacion.curso = curso.id
for respuesta in respuestas:
respuesta_aux = Respuesta()
respuesta_aux.numero_pregunta = respuesta['numero_pregunta']
respuesta_aux.correcta = respuesta['correcta']
respuesta_aux.data = respuesta['respuesta']
evaluacion.respuestas.append(respuesta_aux)
evaluacion.acierto = 0
if 'progreso' in data:
evaluacion.acierto = data['progreso']
evaluacion.save()
return {"Response": 200}
def get(self, id_prueba, id_curso):
args = self.reqparse.parse_args()
token = args.get('auth-token')
alumno = Alumno.load_from_token(token)
apoderado = Apoderado.load_from_token(token)
administrador = Administrador.load_from_token(token)
profesor = Profesor.load_from_token(token)
if alumno == None and apoderado == None and administrador == None and profesor == None:
return {'response': 'user_invalid'}, 401
rowsData = []
prueba = Prueba.objects(id=id_prueba).first()
curso = Curso.objects(id=id_curso).first()
for alumno in Alumno.objects(curso=curso, activo=True).all():
if Evaluacion.objects(prueba=prueba,
alumno=alumno).first() == None:
rowsData.append({
'id': str(alumno.id),
'nombres': alumno.nombres,
'apellido_paterno': alumno.apellido_paterno,
'apellido_materno': alumno.apellido_materno,
'rut': alumno.rut
})
for row in rowsData:
for pregunta in prueba.preguntas:
row[str(pregunta.numero_pregunta)] = ""
return rowsData
def get(self, id_evaluacion):
args = self.reqparse.parse_args()
token = args.get('auth-token')
alumno = Alumno.load_from_token(token)
apoderado = Apoderado.load_from_token(token)
administrador = Administrador.load_from_token(token)
profesor = Profesor.load_from_token(token)
if alumno == None and apoderado == None and administrador == None and profesor == None:
return {'response': 'user_invalid'}, 401
evaluacion = Evaluacion.objects(id=id_evaluacion).first()
rowsData = []
rowsData.append({
'id': str(evaluacion.alumno.id),
'nombres': evaluacion.alumno.nombres,
'apellido_paterno': evaluacion.alumno.apellido_paterno,
'apellido_materno': evaluacion.alumno.apellido_materno,
'rut': evaluacion.alumno.rut
})
for row in rowsData:
for respuesta in evaluacion.respuestas:
if evaluacion.prueba.tipo != "TAREA":
if respuesta.alternativa == "O":
row[str(respuesta.numero_pregunta)] = ""
else:
row[str(
respuesta.numero_pregunta)] = respuesta.alternativa
else:
if respuesta.correcta:
row[str(respuesta.numero_pregunta)] = "correcta"
else:
row[str(respuesta.numero_pregunta)] = "incorrecta"
return rowsData
def get(self, id):
args = self.reqparse.parse_args()
token = args.get('auth-token')
alumno = Alumno.load_from_token(token)
apoderado = Apoderado.load_from_token(token)
administrador = Administrador.load_from_token(token)
profesor = Profesor.load_from_token(token)
if alumno == None and apoderado == None and administrador == None and profesor == None:
return {'response': 'user_invalid'}, 401
labels = []
data = []
prueba = Prueba.objects(id=id).first()
evaluaciones = Evaluacion.objects(prueba=prueba).all()
for pregunta in prueba.preguntas:
labels.append("pregunta " + str(pregunta.numero_pregunta))
for curso in Curso.objects().all():
if prueba.asignatura in curso.asignaturas:
data_curso = []
for pregunta in prueba.preguntas:
cantidad_correctas = 0
for evaluacion in evaluaciones:
if evaluacion.alumno.curso == curso:
for respuesta in evaluacion.respuestas:
if respuesta.numero_pregunta == pregunta.numero_pregunta:
if respuesta.correcta:
cantidad_correctas = cantidad_correctas + 1
data_curso.append(cantidad_correctas)
data.append({"data": data_curso, "label": curso.nombre})
return {"labels": labels, "data": data}
def get(self, id):
args = self.reqparse.parse_args()
token = args.get('auth-token')
alumno = Alumno.load_from_token(token)
apoderado = Apoderado.load_from_token(token)
administrador = Administrador.load_from_token(token)
profesor = Profesor.load_from_token(token)
if alumno == None and apoderado == None and administrador == None and profesor == None:
return {'response': 'user_invalid'}, 401
labels = []
data = []
prueba = Prueba.objects(id=id).first()
for curso in Curso.objects().all():
if prueba.asignatura in curso.asignaturas:
cantidad = 0
promedio = 0
labels.append(curso.nombre)
for evaluacion in Evaluacion.objects(prueba=prueba):
if evaluacion.alumno.curso == curso:
cantidad = cantidad + 1
promedio = promedio + evaluacion.puntaje
if cantidad > 0:
promedio = int(promedio / cantidad)
data.append(promedio)
return {"labels": labels, "data": [data]}
def get(self):
args = self.reqparse.parse_args()
token = args.get('auth-token')
alumno = Alumno.load_from_token(token)
if alumno == None:
return {'response': 'user_invalid'}, 401
asignatura_id = args.get('asignatura_id')
return Evaluacion.get_pruebas_no_respondidas(alumno.id, asignatura_id)
def get(self, id):
args = self.reqparse.parse_args()
token = args.get('auth-token')
alumno = Alumno.load_from_token(token)
apoderado = Apoderado.load_from_token(token)
administrador = Administrador.load_from_token(token)
profesor = Profesor.load_from_token(token)
if alumno == None and apoderado == None and administrador == None and profesor == None:
return {'response': 'user_invalid'}, 401
labels = []
data = []
prueba = Prueba.objects(id=id).first()
for topico in prueba.topicos:
labels.append(topico.nombre)
evaluaciones = Evaluacion.objects(prueba=prueba).all()
for curso in Curso.objects().all():
if prueba.asignatura in curso.asignaturas:
data_curso = []
for topico in prueba.topicos:
#DETERMINAR LA CANTIDAD DE PREGUNTAS ASOCIADAS AL TOPICO Y CUALES SON LAS PREGUNTAS
cantidad_preguntas_topico = 0
numeros_pregunta_topico = []
for pregunta in prueba.preguntas:
if topico == pregunta.topico:
cantidad_preguntas_topico += 1
numeros_pregunta_topico.append(
pregunta.numero_pregunta)
#SACAR EL PROMEDIO DE TODAS LAS EVALUACIONES
suma_promedio_topico_evaluacion = 0
cant_promedio_topico_evaluacion = 0
for evaluacion in evaluaciones:
#ALUMNO PERTENECE AL CURSO
if evaluacion.alumno.curso == curso:
cantidad_correcta_evaluacion = 0
for respuesta in evaluacion.respuestas:
if respuesta.numero_pregunta in numeros_pregunta_topico:
if respuesta.correcta:
cantidad_correcta_evaluacion += 1
#SACAR EL PROMEDIO PARA EVALUACION DEL ALUMNO
promedio_alumno = int(
(cantidad_correcta_evaluacion /
cantidad_preguntas_topico) * 100)
suma_promedio_topico_evaluacion += promedio_alumno
cant_promedio_topico_evaluacion += 1
if cantidad_preguntas_topico > 0 and cant_promedio_topico_evaluacion > 0:
data_curso.append(
int(suma_promedio_topico_evaluacion /
cant_promedio_topico_evaluacion))
else:
data_curso.append(0)
data.append({"data": data_curso, "label": curso.nombre})
print("labels: ", labels)
print("data ", data)
return {"labels": labels, "data": data}
def POST(self):
datos_in = web.input()
periodo = datos_in['periodo']
fecha_final = datos_in['fecha_final']
fecha_inicial = datos_in['fecha_inicial']
tiempo_maximo = datos_in ['tiempo_maximo']
plantilla_id= datos_in['plantilla_id']
evaluacion = Evaluacion.create(periodo, fecha_final, fecha_inicial, tiempo_maximo, plantilla_id)
raise web.redirect('/evaluacion/ver/')
def GET(self):
datos = web.input()
#import ipdb; ipdb.set_trace()
id_evaluacion = datos['id']
evaluacion = Evaluacion.getById(id_evaluacion)
plantillaid = datos['plantilla']
preguntas = Plantilla.getPreguntas(plantillaid)
return render.ver_evaluacion(evaluacion,preguntas)
def test_get_evaluacion_id(client):
evaluacion = Evaluacion.objects().first()
if evaluacion == None:
assert True
else:
rv = client.get('/evaluaciones/'+str(evaluacion.id))
if rv._status_code == 200:
assert True
else:
assert False
def get(self, id_evaluacion):
args = self.reqparse.parse_args()
token = args.get('auth-token')
alumno = Alumno.load_from_token(token)
apoderado = Apoderado.load_from_token(token)
administrador = Administrador.load_from_token(token)
profesor = Profesor.load_from_token(token)
if alumno == None and apoderado == None and administrador == None and profesor == None:
return {'response': 'user_invalid'}, 401
evaluacion = Evaluacion.objects(id=id_evaluacion).first()
return evaluacion.to_dict()
def get(self,id_curso,id_alumno):
curso = Curso.objects(id=id_curso).first()
alumno = Alumno.objects(id=id_alumno).first()
evaluacion = Evaluacion.objects(alumno=alumno.id, curso = curso.id ).first()
respuesta = []
alumno = alumno.to_dict()
respuestas_alumno = []
if evaluacion!=None:
for habilidad_respuesta in curso.habilidades:
preguntas_habilidad = 0
respuestas_correctas_habilidad = 0
for contenido in curso.contenidos:
for pregunta in contenido.preguntas:
if pregunta['habilidad'].id == habilidad_respuesta.id:
preguntas_habilidad = preguntas_habilidad+1
for respuesta_aux in evaluacion.respuestas:
if respuesta_aux.numero_pregunta == pregunta.numero:
if respuesta_aux.correcta:
respuestas_correctas_habilidad = respuestas_correctas_habilidad +1
respuesta_aux = respuesta_aux.to_dict()
respuesta_aux['pregunta'] = pregunta.texto
respuestas_alumno.append(respuesta_aux)
respuesta.append(
{ 'respuesta_correctas': respuestas_correctas_habilidad,
'cantidad_preguntas': preguntas_habilidad,
'habilidad': habilidad_respuesta['nombre']
}
)
alumno['evaluacion'] = True
alumno['progreso'] = evaluacion.acierto
alumno['respuestas_data'] = respuestas_alumno
else:
for habilidad_respuesta in curso.habilidades:
preguntas_habilidad = 0
for contenido in curso.contenidos:
for pregunta in contenido.preguntas:
if pregunta['habilidad'] == habilidad_respuesta:
preguntas_habilidad = preguntas_habilidad+1
respuesta.append(
{ 'respuesta_correctas': 0,
'cantidad_preguntas': preguntas_habilidad,
'habilidad': habilidad_respuesta['nombre']
}
)
alumno['evaluacion'] = False
alumno['progreso'] = 0
alumno['respuestas'] = respuesta
return {
"curso": curso.to_dict(),
"alumno": alumno
}
def put(self, id_evaluacion):
args = self.reqparse.parse_args()
token = args.get('auth-token')
profesor = Profesor.load_from_token(token)
if profesor == None:
return {'response': 'user_invalid'}, 401
evaluacion = Evaluacion.objects(id=id_evaluacion).first()
data = request.data.decode()
data = json.loads(data)
evaluacion.puntaje = int(data['puntaje'])
evaluacion.save()
return {'Response': 'exito'}, 200
def get(self, id_asignatura):
args = self.reqparse.parse_args()
token = args.get('auth-token')
alumno = Alumno.load_from_token(token)
asignatura = Asignatura.objects(id=id_asignatura).first()
if alumno == None:
return {'response': 'user_invalid'}, 401
evaluaciones = []
for evaluacion in Evaluacion.objects(alumno=alumno.id).all():
if evaluacion.prueba.asignatura == asignatura:
evaluaciones.append(evaluacion.to_dict())
return evaluaciones
def post(self):
args = self.reqparse.parse_args()
token = args.get('auth-token')
alumno = Alumno.load_from_token(token)
if alumno == None:
return {'Response': 'user_invalid'}, 401
body = request.data.decode()
body = json.loads(body)
prueba = Prueba.objects(id=body["data"]["prueba_id"]).first()
if prueba == None or not prueba.visible:
return {'Response': 'disabled_prueba'}
return Evaluacion.evaluar_prueba(alumno.id, body["data"])
def get(self, id):
args = self.reqparse.parse_args()
token = args.get('auth-token')
alumno = Alumno.load_from_token(token)
apoderado = Apoderado.load_from_token(token)
administrador = Administrador.load_from_token(token)
profesor = Profesor.load_from_token(token)
if alumno == None and apoderado == None and administrador == None and profesor == None:
return {'response': 'user_invalid'}, 401
response = []
prueba = Prueba.objects(id=id).first()
for evaluacion in Evaluacion.objects(prueba=prueba.id):
response.append(evaluacion.to_dict())
return response
def get(self,id_recurso):
args = self.reqparse.parse_args()
token = args.get('auth-token')
userAdmin = Administrador.load_from_token(token)
userProf = Profesor.load_from_token(token)
if userAdmin == None and userProf == None:
return {'response': 'user_invalid'}, 401
recurso = Curso.objects(id=id_recurso).first()
if recurso == None:
return {'response': 'resorce_invalid'},404
response = []
for evaluacion in Evaluacion.objects(curso=recurso.id).all():
response.append(evaluacion.to_dict())
return response
def get(self):
args = self.reqparse.parse_args()
token = args.get('auth-token')
userAdmin = Administrador.load_from_token(token)
userAlum = Alumno.load_from_token(token)
userProf = Profesor.load_from_token(token)
if userAdmin == None and userAlum == None and userProf == None:
return {'response': 'user_invalid'}, 401
institucion = None
if userAdmin != None:
institucion = Institucion.objects(
id=userAdmin.institucion.id).first()
if userAlum != None:
institucion = Institucion.objects(
id=userAlum.institucion.id).first()
if userProf != None:
institucion = Institucion.objects(
id=userProf.institucion.id).first()
if institucion == None:
return {'response': 'colegio_invalid'}, 404
response = []
profesor = userProf
grados = Grado.objects(profesor=profesor.id).all()
for grado in grados:
if grado.activo:
alumnos = []
cantidad_alumnos = Alumno.objects(grado=grado.id).count()
suma_evaluaciones = 0
for alumno in Alumno.objects(grado=grado.id).all():
alumnos.append(alumno.to_dict(full=False))
for evaluacion in Evaluacion.objects(alumno=alumno.id):
suma_evaluaciones = suma_evaluaciones + evaluacion.acierto
grado = grado.to_dict()
grado['alumnos'] = alumnos
if cantidad_alumnos == 0:
grado['progreso'] = 0
else:
grado['progreso'] = int(suma_evaluaciones /
cantidad_alumnos)
response.append(grado)
return response
def get(self, id):
response = []
profesor = Profesor.objects(id=id).first()
grados = Grado.objects(profesor=profesor.id).all()
for grado in grados:
if grado.activo:
alumnos = []
cantidad_alumnos = Alumno.objects(grado=grado.id).count()
suma_evaluaciones = 0
for alumno in Alumno.objects(grado=grado.id).all():
alumnos.append(alumno.to_dict())
for evaluacion in Evaluacion.objects(alumno=alumno.id):
suma_evaluaciones = suma_evaluaciones + evaluacion.acierto
grado = grado.to_dict()
grado['alumnos'] = alumnos
if cantidad_alumnos == 0:
grado['progreso'] = 0
else:
grado['progreso'] = int(suma_evaluaciones /
cantidad_alumnos)
response.append(grado)
return response
def get(self):
args = self.reqparse.parse_args()
token = args.get('auth-token')
userAdmin = Administrador.load_from_token(token)
if userAdmin == None:
return {'response': 'user_invalid'}, 401
institucion = None
if userAdmin != None:
institucion = Institucion.objects(
id=userAdmin.institucion.id).first()
if institucion == None:
return {'response': 'colegio_invalid'}, 404
data = []
labels = []
for asignatura in Asignatura.objects(institucion=institucion.id,
activo=True).all():
labels.append(asignatura.nombre)
aprobacion = 0
contador = 0
for evaluacion in Evaluacion.objects().all():
if evaluacion.curso.asignatura.id == asignatura.id:
contador = contador + 1
aprobacion = aprobacion + evaluacion.acierto
if contador != 0:
aprobacion = int(aprobacion / contador)
data.append(aprobacion)
aprobacion = 0
return {
"data": [{
"data": data,
"label": "Aprobación"
}],
"labels": labels
}
def get(self):
args = self.reqparse.parse_args()
token = args.get('auth-token')
alumno = Alumno.load_from_token(token)
apoderado = Apoderado.load_from_token(token)
administrador = Administrador.load_from_token(token)
profesor = Profesor.load_from_token(token)
if alumno == None and apoderado == None and administrador == None and profesor == None:
return {'response': 'user_invalid'}, 401
resultado = []
for asignatura in Asignatura.objects().all():
data = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
parcialMes = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
cantEvaluacion = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
for evaluacion in Evaluacion.objects(asignatura=asignatura).all():
indice = int(evaluacion.fecha.strftime("%m")) - 1
parcialMes[indice] = evaluacion.puntaje + parcialMes[indice]
cantEvaluacion[indice] = cantEvaluacion[indice] + 1
i = 0
for i in range(cantEvaluacion.__len__()):
if (cantEvaluacion[i] > 0):
data[i] = int(parcialMes[i] / cantEvaluacion[i])
resultado.append({'data': data, 'label': asignatura.nombre})
return {'asignaturas': resultado}
def get(self, id):
evaluaciones = []
alumno = Alumno.objects(id=id).first()
for evaluacion in Evaluacion.objects(alumno=alumno.id).all():
evaluaciones.append(evaluacion.to_dict())
return evaluaciones
def newEvaluacion():
evaluacion = Evaluacion()
evaluacion.acierto = 1
evaluacion.save()
return evaluacion
def put(self,id_recurso):
args = self.reqparse.parse_args()
user = None
token = args.get('auth-token')
data = request.data.decode()
data = json.loads(data)
user = Alumno.load_from_token(token)
if user == None:
return {'response': 'user_invalid'},401
curso = Curso.objects(id=id_recurso).first()
if curso==None:
return {'response': 'resource_invalid'},404
alumno = user
if len(data) == 0:
return {'response': 'no answers'}, 404
respuestas = data
evaluacion = Evaluacion.objects(alumno=user, curso=curso).first()
if evaluacion != None:
evaluacion.respuestas = []
evaluacion.acierto = 0
evaluacion.save()
if not evaluacion:
evaluacion = Evaluacion()
evaluacion.alumno = alumno.id
evaluacion.curso = curso.id
cantidad_correcta = 0
acierto = 0
#DETERMINAR LA VARIABLE QUE ALMACENARA LAS OPCIONES DE CADA PREGUNTA VALIDA
respuestas_ordenadas = []
for contenido in curso.contenidos:
for pregunta in contenido.preguntas:
if pregunta.tipo_pregunta != "TEXTO":
respuestas_ordenadas.append({
"indice_pregunta":pregunta.indice,
"indice_contenido": contenido.identificador,
"respuestas_enviadas":[]
})
#GUARDO LAS RESPUESTAS ENVIADAS PARA CADA PREGUNTA A PARTIR DE SU INDICE
for respuesta in respuestas:
for respuesta_ordenada in respuestas_ordenadas:
if (int(respuesta['id_contenido']) == int(respuesta_ordenada['indice_contenido'])) and ( int(respuesta['indice_pregunta']) == int(respuesta_ordenada['indice_pregunta'])):
respuesta_ordenada['respuestas_enviadas'].append(respuesta)
#ASEGURARSE DE QUE SE ENVIARON RESPUESTAS PARA TODAS LAS PREGUNTAS EN CASO CONTRARIO RESPONDER FALLO
for respuesta_ordenada in respuestas_ordenadas:
for contenido in curso.contenidos:
if contenido.identificador == respuesta_ordenada['indice_contenido']:
for pregunta in contenido.preguntas:
if pregunta.indice == respuesta_ordenada['indice_pregunta']:
if pregunta.tipo_pregunta != "TEXTO":
if len(respuesta_ordenada['respuestas_enviadas']) == 0:
return {'response': 'answers invalid'}, 404
for respuestas_pregunta in respuestas_ordenadas:
#EN ESTE PUNTO ESTAMOS VIENDO UNA PREGUNTA EN PARTICULAR
# VARIABLE QUE CERTIFICA QUE LA PREGUNTA ES CORRECTA, POR DEFECTO SI ES CORRECTA
correcta= True
# SE CREA LA RESPUESTA QUE SERA ANNADIDA A LA EVALUACION
respuesta_aux = Respuesta()
for contenido in curso.contenidos:
if int(respuestas_pregunta['indice_contenido']) == int(contenido.identificador):
respuesta_aux.indice_contenido = int(respuestas_pregunta['indice_contenido'])
for pregunta in contenido.preguntas:
#ACCEDIMOS A LA PREGUNTA
if int(respuestas_pregunta['indice_pregunta']) == int(pregunta.indice):
#CASO PREGUNTAS DE TIPO TEXTO
if pregunta.tipo_pregunta == "TEXTO":
respuesta_aux.indice_pregunta = pregunta.indice
respuesta_aux.opciones = []
evaluacion.respuestas.append(respuesta_aux)
#CASO PREGUNTAS DE TIPO ALTERNATIVA
if pregunta.tipo_pregunta == "ALTERNATIVA":
#RECORRER LAS OPCIONES ENVIADAS
for respuesta_enviada in respuestas_pregunta['respuestas_enviadas']:
if respuesta_enviada['respuesta'] == "True":
#VERIFICAR QUE ES LA CORRECTA O NO
for alternativa in pregunta.alternativas:
if alternativa.correcta:
#SI LA ALTERNATIVA ES CORRECTA VER SI COINCIDE CON LO SE MANDO
if int(respuesta_enviada['indice_opcion']) != int(alternativa.numero_alternativa):
correcta = False
# SE TIENE QUE GUARDAR LA OPCION DE LA RESPUESTA
respuesta_opcion = RespuestaOpcion()
respuesta_opcion.numero_opcion = int(respuesta_enviada['indice_opcion'])
respuesta_opcion.correcta = correcta
respuesta_opcion.data = str(respuesta_enviada['respuesta'])
respuesta_aux.opciones.append(respuesta_opcion)
respuesta_aux.indice_pregunta = pregunta.indice
respuesta_aux.correcta = correcta
# SE GUARDA LA RESPUESTA A LA PREGUNTA EN LA EVALUACION
evaluacion.respuestas.append(respuesta_aux)
#CASO PREGUNTA VERDADERO Y FALSO
if pregunta.tipo_pregunta == "VERDADERO_FALSO":
#RECORRER LAS OPCIONES ENVIADAS
for respuesta_enviada in respuestas_pregunta['respuestas_enviadas']:
#POR CADA OPCION SE TIENE QUE CREAR UNA RESPUESTAOPCION Y VERIFICAR SI SE FALLÓ
#SETEAR CORECTA A FALSO
#RECORRER LAS ALTERNATIVAS
respuesta_opcion = RespuestaOpcion()
correcta_opcion = False
for alternativa in pregunta.alternativas:
if alternativa.numero_alternativa == int(respuesta_enviada['indice_opcion']):
if str(alternativa.correcta) == str(respuesta_enviada['respuesta']):
correcta_opcion = True
else:
correcta_opcion = False
correcta = False
respuesta_opcion.numero_opcion = int(respuesta_enviada['indice_opcion'])
respuesta_opcion.data = str(respuesta_enviada['respuesta'])
respuesta_opcion.correcta = correcta_opcion
respuesta_aux.opciones.append(respuesta_opcion)
respuesta_aux.indice_pregunta = pregunta.indice
respuesta_aux.correcta = correcta
# SE GUARDA LA RESPUESTA A LA PREGUNTA EN LA EVALUACION
evaluacion.respuestas.append(respuesta_aux)
#CASO UNIR PARES
if pregunta.tipo_pregunta == "UNIR_IMAGENES" or pregunta.tipo_pregunta == "UNIR_TEXTOS" or pregunta.tipo_pregunta == "UNIR_IMAGEN_TEXTO":
for respuesta_enviada in respuestas_pregunta['respuestas_enviadas']:
respuesta_opcion = RespuestaOpcion()
if int(respuesta_enviada['respuesta']) == int(respuesta_enviada['indice_opcion']):
correcta = True
else:
correcta = False
respuesta_opcion.numero_opcion = respuesta_enviada['indice_opcion']
respuesta_opcion.data = str(respuesta_enviada['respuesta'])
respuesta_opcion.correcta = correcta
respuesta_aux.opciones.append(respuesta_opcion)
respuesta_aux.indice_pregunta = pregunta.indice
respuesta_aux.correcta = correcta
evaluacion.respuestas.append(respuesta_aux)
# ACTUALIZAR CONTADOR DE LAS RESPUESTAS CORRECTAS
if correcta:
cantidad_correcta = cantidad_correcta + 1
if len(respuestas_ordenadas)>0:
cantidad_preguntas = 0
for contenido in curso.contenidos:
for pregunta in contenido.preguntas:
if pregunta.tipo_pregunta != "TEXTO":
cantidad_preguntas = cantidad_preguntas +1
if cantidad_preguntas == 0:
acierto = 0
else:
acierto = int((cantidad_correcta/cantidad_preguntas)*100)
evaluacion.acierto = acierto
evaluacion.json = json.dumps(data)
evaluacion.save()
#ACTUALIZAR LA APROBACION DEL RECURSO
curso.actualizar_aprobacion()
curso.save()
#return {"Response": 200}
return {"Response":respuestas_ordenadas}
def get(self, id):
args = self.reqparse.parse_args()
token = args.get('auth-token')
alumno = Alumno.load_from_token(token)
apoderado = Apoderado.load_from_token(token)
administrador = Administrador.load_from_token(token)
profesor = Profesor.load_from_token(token)
if alumno == None and apoderado == None and administrador == None and profesor == None:
return {'response': 'user_invalid'}, 401
alumno = Alumno.objects(id=id).first()
evaluaciones = Evaluacion.objects(alumno=alumno.id).all()
evaluaciones_matematicas = []
evaluaciones_lenguaje = []
ponderacion_matematicas = 0
ponderacion_lenguaje = 0
colegio = ""
if alumno.colegio != None:
colegio = alumno.colegio.nombre
for evaluacion in evaluaciones:
if (evaluacion.prueba.asignatura.nombre
== 'Matemáticas') and (evaluacion.prueba.tipo != "TAREA"):
evaluaciones_matematicas.append(evaluacion)
if (evaluacion.prueba.asignatura.nombre
== 'Lenguaje') and (evaluacion.prueba.tipo != "TAREA"):
evaluaciones_lenguaje.append(evaluacion)
for evaluacion_mat in evaluaciones_matematicas:
ponderacion_matematicas = ponderacion_matematicas + evaluacion_mat.puntaje
for evaluacion_leng in evaluaciones_lenguaje:
ponderacion_lenguaje = ponderacion_lenguaje + evaluacion_leng.puntaje
promedio_mat = 0
promedio_leng = 0
if ponderacion_matematicas > 0:
promedio_mat = int(
(ponderacion_matematicas) / evaluaciones_matematicas.__len__())
if ponderacion_lenguaje > 0:
promedio_leng = int(
(ponderacion_lenguaje) / evaluaciones_lenguaje.__len__())
asistencias = Asistencia.objects(curso=alumno.curso).all()
cantidad_presente = 0
for asistencia in asistencias:
for alumno_presente in asistencia.alumnos_presentes:
if alumno_presente.id == alumno.id:
cantidad_presente = cantidad_presente + 1
promedio_asistencia = 0
if cantidad_presente > 0:
promedio_asistencia = int(
100 * (cantidad_presente / asistencias.__len__()))
observaciones = json.loads(
Observacion.objects(alumno=alumno).all().to_json())
return {
'id':
str(alumno.id),
'nombres':
alumno.nombres,
'calegio':
colegio,
'curso':
alumno.curso.nombre,
'curso_id':
str(alumno.curso.id),
'apellido_paterno':
alumno.apellido_paterno,
'apellido_materno':
alumno.apellido_materno,
'telefono':
alumno.telefono,
'email':
alumno.email,
'ponderacion_matematicas':
promedio_mat,
'ponderacion_lenguaje':
promedio_leng,
'ponderacion_asistencia':
promedio_asistencia,
'observaciones':
observaciones,
'imagen':
alumno.imagen,
'direccion':
alumno.direccion.calle + " " + alumno.direccion.numero + ", " +
alumno.direccion.comuna
}
def get(self, id):
args = self.reqparse.parse_args()
token = args.get('auth-token')
alumno = Alumno.load_from_token(token)
apoderado = Apoderado.load_from_token(token)
administrador = Administrador.load_from_token(token)
profesor = Profesor.load_from_token(token)
if alumno == None and apoderado == None and administrador == None and profesor == None:
return {'response': 'user_invalid'}, 401
labels = []
data_ensayo = []
data_taller = []
data_tarea = []
alumno = Alumno.objects(id=id).first()
for asignatura in alumno.curso.asignaturas:
labels.append(asignatura.nombre)
suma_ensayo = 0
suma_taller = 0
suma_tarea = 0
for prueba in Prueba.objects(asignatura=asignatura,
tipo="ENSAYO").all():
puntaje = 0
evaluacion = Evaluacion.objects(alumno=alumno.id,
prueba=prueba.id).first()
if evaluacion != None:
puntaje = evaluacion.puntaje
suma_ensayo = suma_ensayo + puntaje
for prueba in Prueba.objects(asignatura=asignatura,
tipo="TALLER").all():
puntaje = 0
evaluacion = Evaluacion.objects(alumno=alumno.id,
prueba=prueba.id).first()
if evaluacion != None:
puntaje = evaluacion.puntaje
suma_taller = suma_taller + puntaje
for prueba in Prueba.objects(asignatura=asignatura,
tipo="TAREA").all():
puntaje = 0
evaluacion = Evaluacion.objects(alumno=alumno.id,
prueba=prueba.id).first()
if evaluacion != None:
puntaje = evaluacion.puntaje
suma_tarea = suma_tarea + puntaje
if Prueba.objects(asignatura=asignatura,
tipo="ENSAYO").count() > 0:
data_ensayo.append(
int((suma_ensayo / Prueba.objects(asignatura=asignatura,
tipo="ENSAYO").count())))
if Prueba.objects(asignatura=asignatura,
tipo="ENSAYO").count() == 0:
data_ensayo.append(int(suma_ensayo))
if Prueba.objects(asignatura=asignatura,
tipo="TALLER").count() > 0:
data_taller.append(
int((suma_taller / Prueba.objects(asignatura=asignatura,
tipo="TALLER").count())))
if Prueba.objects(asignatura=asignatura,
tipo="TALLER").count() == 0:
data_taller.append(int(suma_taller))
if Prueba.objects(asignatura=asignatura, tipo="TAREA").count() > 0:
data_tarea.append(
int((suma_tarea / Prueba.objects(asignatura=asignatura,
tipo="TAREA").count())))
if Prueba.objects(asignatura=asignatura,
tipo="TAREA").count() == 0:
data_tarea.append(int(suma_tarea))
return {
"labels":
labels,
"data": [{
"data": data_ensayo,
"label": "Ensayo"
}, {
"data": data_taller,
"label": "Taller"
}, {
"data": data_tarea,
"label": "Tarea"
}]
}
def get(self):
print(Evaluacion.objects().all().to_json())
return json.loads(Evaluacion.objects().all().to_json())
def get(self, id):
return json.loads(Evaluacion.objects(id=id).first().to_json())