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 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):
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 = []
for categoria in Categoria.objects().all():
if categoria.activo:
cursos = Curso.objects(categoria=categoria.id,
institucion=institucion.id).count()
cursosCerrados = Curso.objects(
activo=False,
categoria=categoria.id,
institucion=institucion.id).count()
categoria = categoria.to_dict()
categoria['cursos'] = cursos
categoria['cursosCerrados'] = cursosCerrados
response.append(categoria)
return response
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 get(self,id):
curso = Curso.objects(id=id).first()
print(curso)
curso_base = CursoBase.objects(id=curso.curso_base.id).first()
imagen = Image.open("./uploads/cursos/"+str(curso_base.id)+".jpg")
imagen.save(os.path.join("./uploads/cursos", str(id)+".jpg"))
imagen.thumbnail((500, 500))
imagen.save(os.path.join("./uploads/cursos", str(id)+'_thumbnail.jpg'))
curso = Curso.objects(id=id).first()
curso.imagen = str(id)
curso.save()
return {'Response': 'exito'}
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 delete(self, id_curso, id_alumno):
idAlumno = ObjectId(id_alumno)
alumnos = []
curso = Curso.objects(id=id_curso).first()
for alumno in curso.alumnos:
if(idAlumno != alumno.id):
alumnos.append(alumno.id)
response = Curso.objects(id=id_curso).update(
set__alumnos = alumnos
)
if(response):
return {'Response': 'exito'}
def post(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
data = request.data.decode()
data = json.loads(data)
curso = Curso()
curso.nombre = data['nombre']
curso.save()
return {'Response': 'exito'}
def get(self):
labels = []
data = []
for asignatura in Asignatura.objects().all():
labels.append(asignatura.nombre)
data.append(Curso.objects(asignatura=asignatura.id).count())
return { 'data': data, '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 get(self, id_recurso):
args = self.reqparse.parse_args()
user = None
token = args.get('auth-token')
user = Alumno.load_from_token(token)
user_prof = Profesor.load_from_token(token)
user_admin = Administrador.load_from_token(token)
if user == None and user_admin == None and user_prof == None:
return {'response': 'user_invalid'},401
if len(id_recurso.encode('utf-8')) != 24:
return {'response': 'bad_request'},400
curso = Curso.objects(id=id_recurso).first()
if curso==None:
return {'response': 'resource_invalid'},404
response = {}
response['id'] = str(curso.id)
response['nombre'] = curso.nombre
response['fecha_creacion'] = str(curso.fecha_creacion)
response['asignatura'] = curso.asignatura.to_dict()
response['profesor'] = curso.profesor.to_dict()
contenidos = []
for contenido in curso.contenidos:
preguntas = []
for pregunta in contenido.preguntas:
if pregunta.tipo_pregunta == "ALTERNATIVA" or pregunta.tipo_pregunta == "VERDADERO_FALSO":
opciones = []
for opcion in pregunta.alternativas:
opciones.append(opcion.to_dict())
preguntas.append({
"tipo": pregunta.tipo_pregunta,
"indice": pregunta.indice,
"texto": pregunta.texto,
"habilidad": pregunta.habilidad.to_dict(),
"opciones": opciones
})
if pregunta.tipo_pregunta == "TEXTO":
preguntas.append({
"tipo": pregunta.tipo_pregunta,
"indice": pregunta.indice,
"texto": pregunta.texto
})
if pregunta.tipo_pregunta == "UNIR_IMAGENES" or pregunta.tipo_pregunta == "UNIR_TEXTOS" or pregunta.tipo_pregunta == "UNIR_IMAGEN_TEXTO":
opciones = []
for opcion in pregunta.alternativas:
opciones.append(opcion.to_dict())
preguntas.append({
"tipo": pregunta.tipo_pregunta,
"indice": pregunta.indice,
"texto": pregunta.texto,
"habilidad": pregunta.habilidad.to_dict(),
"opciones": opciones
})
contenidos.append({
"identificador" : contenido.identificador,
"preguntas" : preguntas
})
response['contenidos'] = contenidos
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 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):
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 = []
asignaturas = Asignatura.objects(institucion=institucion).all()
for asignatura in asignaturas:
if asignatura.activo:
cursos_lista = []
cursos = Curso.objects(asignatura=asignatura.id,
clon_padre=None).all()
for curso in cursos:
cursos_lista.append({'nombre': curso.nombre})
response.append({
'id': str(asignatura.id),
'nombre': asignatura.nombre,
'cursos': cursos_lista
})
return response
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):
resultado = []
cursos = Curso.objects().all()
for curso in cursos:
profesor = ""
asignatura = ""
if curso.profesor != None:
profesor = curso.profesor.nombres+" "+curso.profesor.apellido_paterno
if curso.asignatura != None:
asignatura = curso.asignatura.nombre
diccionario_aux ={
"id": str(curso.id),
"nombre": curso.nombre,
"cant_estudiantes": len(curso.alumnos),
"profesor": profesor,
"nombre_asignatura": asignatura,
"codigo_curso": str(curso.id),
"curso_base": curso.curso_base.nombre,
"version": curso.version,
"creacion": str(curso.fecha_creacion),
"activo": curso.activo,
"imagen": curso.imagen
}
resultado.append(diccionario_aux)
return resultado
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 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 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 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_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 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 test_delete_recurso_item(client):
recurso = Curso.objects().first()
if recurso == None:
assert False
rv = client.delete('/recurso/' + str(recurso.id))
if rv._status_code == 200:
return True
assert False
def test_get_recurso_imagen_default(client):
recurso = Curso.objects().first()
if recurso == None:
assert False
rv = client.get('/recurso/imagen/default/' + str(recurso.id))
if rv._status_code == 200:
return True
assert False
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 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 get(self, id):
cursosRespuesta = []
alumno = Alumno.objects(id=id).first()
if alumno.institucion == None:
for curso in Curso.objects(clon_padre=None,
institucion=None,
activo=True).all():
if alumno in curso.alumnos:
cursosRespuesta.append(curso.to_dict())
else:
for curso in Curso.objects(
clon_padre=None,
publicado=True,
activo=True,
institucion=alumno.institucion.id).all():
if alumno in curso.alumnos:
cursosRespuesta.append(curso.to_dict())
return cursosRespuesta
def create_layout_excel(cls):
headers = [
"RUN", "Nombres", "Apellido Paterno", "Apellido Materno",
"Puntaje Ingreso", "Sexo (MASCULINO/FEMENINO/NO DEFINIDO)",
"Email", "Telefono", "Calle", "Numero", "Comuna", "Villa/Depto",
"Id. Curso", "Id. Colegio"
]
result_list = [Colegio.export_to_excel(), Curso.export_to_excel()]
return create_excel(result_list, headers, "Formato_alumnos")
def post(self,id):
imagen = Image.open(request.files['imagen'].stream).convert("RGB")
imagen.save(os.path.join("./uploads/cursos", str(id)+".jpg"))
imagen.thumbnail((500, 500))
imagen.save(os.path.join("./uploads/cursos", str(id)+'_thumbnail.jpg'))
curso = Curso.objects(id=id).first()
curso.imagen = str(id)
curso.save()
return {'Response': 'exito'}
def test_put_recurso_item(client):
recurso = Curso.objects().first()
if recurso == None:
assert True
else:
rv = client.put('/recurso/' + str(recurso.id))
if rv._status_code == 200:
assert True
else:
assert False
