def post(self):
args = self.reqparse.parse_args()
email = args.get("email")
passwd = args.get("password")
tipo = args.get("tipo")
user = None
if tipo == 'ALUMNO':
if (email.find('@') != -1):
user = Alumno.objects(email=email).first()
else:
user = Alumno.objects(nombre_usuario=email).first()
elif tipo == 'ADMINISTRADOR':
if (email.find('@') != -1):
user = Administrador.objects(email=email).first()
else:
user = Administrador.objects(nombre_usuario=email).first()
elif tipo == 'PROFESOR':
if (email.find('@') != -1):
user = Profesor.objects(email=email).first()
else:
user = Profesor.objects(nombre_usuario=email).first()
if user != None and user.activo and user.check_password(passwd):
res = []
if tipo == "ALUMNO":
res_bd = Curso.objects(alumnos__in=[user],
clon_padre=None,
activo=True,
publicado=True).all()
else:
res_bd = Curso.objects(profesor=user,
clon_padre=None,
activo=True).all()
for resource in res_bd:
res.append({
"id":
str(resource.id),
"nombre":
resource.nombre,
"fecha_creacion":
resource.fecha_creacion.isoformat(),
"activo":
resource.activo,
"version":
resource.version,
"id_base":
str(resource.curso_base.id),
})
return {
'respuesta': user.to_dict(),
'tipo': tipo,
'token': str(user.get_token()),
'recursos': res
}
return abort(403)
def put(self, id):
args = self.reqparse.parse_args()
token = args.get('auth-token')
alumno = Alumno.objects(id=id).first()
administrador = Administrador.load_from_token(token)
if alumno == None and administrador == None:
return {'response': 'user_invalid'}, 401
data = request.data.decode()
data = json.loads(data)
alumno.nombres = data['nombres']
alumno.apellido_paterno = data['apellido_paterno']
alumno.apellido_materno = data['apellido_materno']
alumno.telefono = data['telefono']
alumno.email = data['email']
alumno.sexo = data['sexo']
alumno.rut = data['rut']
alumno.puntaje_ingreso = data['puntaje_ingreso']
direccion = Direccion(calle=data['calle'],
numero=data['numero'],
comuna=data['comuna'],
cas_dep_of=data['cas_dep_of'])
alumno.direccion = direccion
colegio = Colegio.objects(id=data['colegio']).first()
curso = Curso.objects(id=data['curso']).first()
alumno.colegio = colegio
alumno.curso = curso
alumno.save()
colegio.updateCantEstudiantes()
curso.updateCantEstudiantes()
colegio.save()
curso.save()
return {'Response': 'exito', 'id': str(alumno.id)}
def get(self, id_curso):
alumnos_array = []
curso = Curso.objects(id=id_curso, clon_padre=None).first()
for alumno_obj in Alumno.objects().all():
if alumno_obj.curso == curso:
alumnos_array.append(alumno_obj.to_dict())
return alumnos_array
def test_post_cursos(client):
institucion = Institucion.objects().first()
asignatura = Asignatura.objects().first()
profesor = Profesor.objects().first()
alumnos = Alumno.objects().all()
grado = Grado.objects().first()
curso_base = CursoBase.objects().first()
if ((institucion == None) or (asignatura == None) or (profesor == None)
or (alumnos == None) or (grado == None) or (curso_base == None)):
assert True
else:
alumnos_array = []
for alumno in alumnos:
alumnos_array.append(alumno.id)
data = {
'nombre': 'nombre',
'fecha_creacion': '01/01/2000',
'preguntas': [],
'asignatura': str(asignatura.id),
'institucion': str(institucion.id),
'profesor': str(profesor.id),
'alumnos': alumnos_array,
'grado': str(grado.id),
'activo': True,
'version': '1.0',
'curso_base': str(curso_base.id),
'descripcion': 'descripcion del curso'
}
token = profesor.get_token()
rv = client.post('/recursos', data=data, headers={'auth-token': token})
if rv._status_code == 200:
assert True
else:
assert False
def put(self):
#Cargar datos dinamicos
data = request.data.decode()
data = json.loads(data)
idCurso = data['id']
data = data['data']
cursoBase = CursoBase.objects(id=data['curso_base']).first()
asignatura = Asignatura.objects(id=data['asignatura']).first()
institucion = Institucion.objects(id=data['institucion']).first()
profesor = Profesor.objects(id=data['profesor']).first()
alumnos = Alumno.objects(id=data['alumnos']).first()
pregunta = Pregunta()
curso = Curso.objects(id=idCurso).first()
curso.nombre = data['nombre']
curso.fecha_creacion = '10/06/2012'
curso.preguntas = [pregunta]
curso.asignatura = asignatura.id
curso.institucion = institucion.id
curso.profesor = profesor.id
curso.alumnos = [alumnos.id]
curso.activo = True
curso.version = data['version']
curso.curso_base = cursoBase.id
curso.save()
return {'test': 'test'}
def test_put_recursos(client):
curso = Curso.objects().first()
institucion = Institucion.objects().first()
asignatura = Asignatura.objects().first()
profesor = Profesor.objects().first()
alumno = Alumno.objects().first()
grado = Grado.objects().first()
curso_base = CursoBase.objects().first()
if((institucion == None) or (asignatura == None) or \
(profesor == None) or (alumno == None) or \
(grado == None) or (curso_base == None) or (curso == None)):
assert False
data = {
'nombre': 'nombre',
'fecha_creacion': '01/01/2000',
'preguntas': [],
'asignatura': str(asignatura.id),
'institucion': str(institucion.id),
'profesor': str(profesor.id),
'alumnos': str(alumno.id),
'grado': str(grado.id),
'activo': True,
'version': 1,
'curso_base': str(curso_base.id),
'descripcion': 'descripcion del curso'
}
data_put = {'id': str(curso.id), 'data': data}
data_put = json.dumps(data_put)
data_put = data_put.encode()
rv = client.put('/recursos', data=data_put)
if rv._status_code == 200:
return True
assert False
def get(self, id):
response = []
grados = Grado.objects(institucion=id).all()
for grado in grados:
if grado.activo:
cursosGrado = Curso.objects(grado=grado.id).count()
alumnosGrados = 0
for alumno in Alumno.objects(grado=grado.id).all():
if alumno.activo:
alumnosGrados = alumnosGrados + 1
cursos = Curso.objects(grado=grado.id).all()
aprobacion = 0
for curso in cursos:
aprobacion = aprobacion + curso.aprobacion
if cursosGrado > 0:
aporbacion = aprobacion / cursosGrado
response.append({
'id': str(grado.id),
'nivel': grado.nivel,
'identificador': grado.identificador,
'cant_cursos': cursosGrado,
'cant_alumnos': alumnosGrados,
'aprobacion': aprobacion
})
return response
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 post(self):
args = self.reqparse.parse_args()
email = args.get("email")
passwd = args.get("password")
tipo = args.get("tipo")
recursos = []
user = None
if tipo == 'ALUMNO':
user = Alumno.objects(email=email).first()
for recurso in Curso.objects(alumnos__in=[user]).all():
recursos.append(recurso.to_dict())
elif tipo == 'ADMINISTRADOR':
user = administrador = Administrador.objects(email=email).first()
elif tipo == 'PROFESOR':
user = Profesor.objects(email=email).first()
for recurso in Curso.objects(profesor=user).all():
recursos.append(recurso.to_dict())
if user and user.activo and user.check_password(passwd):
return {
'respuesta': {
'id': str(user.id)
},
'tipo': tipo,
'token': str(user.get_token()),
'recursos': recursos
}
print('testingggg')
return {'respuesta': 'no_existe'}, 401
def get(self):
response = []
alumnos = Alumno.objects().all()
for alumno in alumnos:
if alumno.activo:
response.append(alumno.to_dict())
return response
def get(self, id_institucion):
institucion = Institucion.objects(id = id_institucion).first()
alumnos = []
for alumno in Alumno.objects(institucion = id_institucion).all():
alumnos.append(alumno.to_dict())
return alumnos
def post(self, id_curso, nombre_usuario):
alumno = Alumno.objects(nombre_usuario= nombre_usuario).first()
alumnos = Alumno.objects().all()
if alumno == None:
return {'Response': 'no_existe'}
curso = Curso.objects(id=id_curso).first()
if not alumno.activo:
return {'Response': 'no_existe'}
for alumno_aux in curso.alumnos:
if alumno_aux.id == alumno.id:
return {'Response': 'si_pertenece'}
curso.alumnos.append(alumno.id)
curso.save()
return {'Response': 'exito'}
def put(self, id):
args = self.reqparse.parse_args()
token = args.get('auth-token')
apoderado = Apoderado.objects(id=id).first()
administrador = Administrador.load_from_token(token)
if apoderado == None and administrador == None:
return {'response': 'user_invalid'}, 401
data = request.data.decode()
data = json.loads(data)
apoderado.nombres = data['nombres']
apoderado.apellido_paterno = data['apellido_paterno']
apoderado.apellido_materno = data['apellido_materno']
apoderado.telefono = data['telefono']
apoderado.email = data['email']
apoderado.rut = data['rut']
direccion = Direccion(calle=data['calle'],
numero=data['numero'],
comuna=data['comuna'],
cas_dep_of=data['cas_dep_of'])
apoderado.direccion = direccion
#Asignar alumno
alumno = Alumno.objects(rut=data['rut_alumno']).first()
if alumno == None:
return {'Response': 'not_alumno'}
else:
apoderado.alumno = alumno
apoderado.save()
return {'Response': 'exito', 'id': str(apoderado.id)}
def get(self, id):
alumnos = []
grado = Grado.objects(id=id).first()
for alumno in Alumno.objects().all():
if alumno.grado == grado:
if alumno.activo:
alumnos.append(alumno.to_dict())
return alumnos
def post(self):
data = request.data.decode()
data = json.loads(data)
curso = Curso.objects(id=data['id_curso']).first()
alumno = Alumno.objects(id=data['id_alumno']).first()
curso.alumnos.remove(alumno)
curso.save()
return {'Response': 'exito'}
def test_get_recurso_disponible(client):
alumno = Alumno.objects().first()
if alumno == None:
assert False
rv = client.get('/recursos/disponibles/alumno/' + str(alumno.id))
if rv._status_code == 200:
return True
assert False
def test_get_alumno_evaluaciones(client):
alumno = Alumno.objects().first()
if alumno == None:
assert False
rv = client.get('/alumno/evaluaciones/'+str(alumno.id))
if rv._status_code == 200:
return True
assert False
def test_delete_alumno(client):
alumno = Alumno.objects().first()
if alumno == None:
assert False
rv = client.delete('/alumnos/'+str(alumno.id))
if rv._status_code == 200:
return True
assert False
def test_get_finalizar_tutorial(client):
alumno = Alumno.objects().first()
if alumno == None:
assert False
rv = client.get('/alumno/finalizar/tutorial/'+str(alumno.id))
if rv._status_code == 200:
return True
assert False
def test_get_alumno_imagen_zoom(client):
alumno = Alumno.objects().first()
if alumno == None:
assert False
rv = client.get('/imagen/zoom/'+str(alumno.id))
if rv._status_code == 200:
return True
assert False
def updateCantEstudiantes(self):
from models.alumno import Alumno
alumnos = Alumno.objects(curso=self.id).all()
contador = 0
for alumno in alumnos:
if alumno.activo:
contador = contador + 1
self.cantidad_estudiantes = contador
return True
def test_post_alumno_recurso(client):
curso = newCurso()
alumno = Alumno.objects().first()
if curso == None or alumno == None:
assert False
rv = client.post('/alumno/recurso/'+str(alumno.nombre_usuario)+'/'+str(curso.id))
if rv._status_code == 200:
return True
assert False
def test_get_recurso_detalle_alumno(client):
alumno = Alumno.objects().first()
recurso = Curso.objects().first()
if alumno == None or recurso == None:
assert False
rv = client.get('/recurso/detalle/alumno/' + str(recurso.id) + '/' +
str(alumno.id))
if rv._status_code == 200:
return True
assert False
def test_get_alumno(client):
alumno = Alumno.objects().first()
if alumno == None:
assert True
else:
rv = client.get('/alumnos/' + str(alumno.id))
if rv._status_code == 200:
assert True
else:
assert False
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
return Alumno.objects(id=id).first().to_dict()
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 post(self, id):
data = request.data.decode()
data = json.loads(data)
institucion = Institucion.objects(id=id).first()
administrador = Administrador.objects(
email=data['email'], institucion=institucion.id).first()
profesor = Profesor.objects(email=data['email'],
institucion=institucion.id).first()
alumno = Alumno.objects(email=data['email'],
institucion=institucion.id).first()
if administrador != None:
if (administrador.check_password(data['password'])
or administrador.activo == False):
token = administrador.get_token()
return {
'respuesta': {
'id': str(administrador.id)
},
'tipo': 'ADMINISTRADOR',
'token': str(token)
}
else:
return {'respuesta': 'no_existe'}, 401
if profesor != None:
if (profesor.check_password(data['password'])
or administrador.activo == False):
token = profesor.get_token()
return {
'respuesta': {
'id': str(profesor.id)
},
'tipo': 'PROFESOR',
'token': str(token)
}
else:
return {'respuesta': 'no_existe'}, 401
if alumno != None:
if (alumno.check_password(data['password'])
or administrador.activo == False):
token = alumno.get_token()
return {
'respuesta': {
'id': str(alumno.id)
},
'tipo': 'ALUMNO',
'token': str(token)
}
else:
return {'respuesta': 'no_existe'}, 401
else:
return {'respuesta': 'no_existe'}, 404
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 delete(self, id_curso, nombre_usuario):
alumno = Alumno.objects(nombre_usuario=nombre_usuario).first()
alumnos = []
curso = Curso.objects(id=id_curso, clon_padre=None).first()
for alumno_curso in curso.alumnos:
if (alumno.id != alumno_curso.id):
alumnos.append(alumno.id)
response = Curso.objects(id=id_curso,
clon_padre=None).update(set__alumnos=alumnos)
if (response):
return {'Response': 'exito'}
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
}
