def post(self):
data = request.data.decode()
data = json.loads(data)
asignatura = Asignatura()
asignatura.nombre = data['nombre']
asignatura.save()
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)
asignatura = Asignatura()
asignatura.nombre = data['nombre']
asignatura.save()
return {'Response': 'exito'}
def get(self):
asignaturas = Asignatura.objects().all()
response = []
for asignatura in asignaturas:
if asignatura.activo:
response.append(asignatura.to_dict())
return response
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 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 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)
profesor = Profesor()
profesor.nombres = data['nombres']
profesor.apellido_paterno = data['apellido_paterno']
profesor.apellido_materno = data['apellido_materno']
profesor.telefono = data['telefono']
profesor.email = data['email']
profesor.encrypt_password(data['rut'])
profesor.rut = data['rut']
direccion = Direccion(calle=data['calle'],
numero=data['numero'],
comuna=data['comuna'],
cas_dep_of=data['cas_dep_of'])
profesor.direccion = direccion
asignatura = Asignatura.objects(id=data['asignatura']).first()
profesor.asignatura = asignatura.id
profesor.save()
return {'Response': 'exito', 'id': str(profesor.id)}
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):
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 test_delete_asignatura(client):
asignatura = Asignatura.objects().first()
if asignatura == None:
assert False
rv = client.delete('/asignaturas/' + str(asignatura.id))
if rv._status_code == 200:
return True
assert False
def test_get_recursos_aprobacion_grafico(client):
asignatura = Asignatura.objects().first()
if asignatura == None:
assert False
rv = client.get('/recursos/aprobacion/graficos/' + str(asignatura.id))
if rv._status_code == 200:
return True
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 Asignatura.objects(id=id).first().to_dict()
def test_get_asignatura(client):
asignatura = Asignatura.objects().first()
if asignatura == None:
assert True
else:
rv = client.get('/asignaturas/'+str(asignatura.id))
if rv._status_code == 200:
assert True
else:
assert False
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 test_put_asignatura(client):
asignatura = Asignatura.objects().first()
institucion = Institucion.objects().first()
if (asignatura == None or institucion == None):
assert False
data = {'nombre': 'nombre', 'institucion': str(institucion.id)}
data = json.dumps(data)
data = data.encode()
rv = client.put('/asignaturas/' + str(asignatura.id), data=data)
if rv._status_code == 200:
return True
assert False
def put(self, id):
asignatura = Asignatura.objects(id=id).first()
cursos = Curso.objects(asignatura=asignatura.id).all()
for curso in cursos:
curso.asignatura = None
curso.save()
data = request.data.decode()
data = json.loads(data)
asignatura.nombre = data['nombre']
asignatura.save()
return {'Response': 'exito'}
def post(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
data = request.data.decode()
data = json.loads(data)
asignatura = Asignatura()
asignatura.nombre = data['nombre']
asignatura.institucion = institucion
asignatura.save()
return {'Response': 'exito'}
def delete(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
asignatura = Asignatura.objects(id=id).first()
asignatura.activo = False
asignatura.save()
return {'Response': 'exito'}
def to_dict(self):
asignaturas = []
for asignatura in self.asignaturas:
asignatura = Asignatura.objects(id=asignatura.id).first()
if asignatura.activo:
asignaturas.append(asignatura.to_dict())
return {
"id": str(self.id),
"nombre": self.nombre,
"cantidad_estudiantes": self.cantidad_estudiantes,
"asignaturas": asignaturas
}
def get(self, id):
cursosRespuesta = []
cursos = Curso.objects().all()
for curso in cursos:
if curso.alumnos != None:
esta_alumno = False
for alumno in curso.alumnos:
if str(alumno.id) == str(id):
esta_alumno = True
if esta_alumno:
asignatura = Asignatura.objects(id=curso.asignatura.id).first()
profesor = Profesor.objects(id=curso.profesor.id).first()
cursosRespuesta.append(curso.to_dict())
return cursosRespuesta
def upload(cls, base_path, new_file, asignatura_id):
asignatura = Asignatura.objects(id=asignatura_id).first()
folder = base_path + str(asignatura['id'])
if not os.path.exists(folder):
os.mkdir(folder)
file_name = secure_filename(new_file.filename)
path = os.path.join(folder, file_name)
new_file.save(path)
if os.path.exists(path):
archivo = Archivo(nombre=file_name,
path=path,
asignatura=asignatura)
archivo.save()
return archivo.to_dict()
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
response = []
asignatura = Asignatura.objects(id=profesor.asignatura.id).first()
for alerta in Alerta.objects(asignatura=asignatura.id).all():
response.append(alerta.to_dict())
return response
def create(cls, new_video):
asignatura = Asignatura.objects(id=new_video["asignatura_id"]).first()
curso = Curso.objects(id=new_video["curso_id"]).first()
id_video = new_video['uri'].split("?v=")
id_video = id_video[1]
if "&" in id_video:
id_video = id_video.split("&")[0]
embed_link = "https://www.youtube.com/embed/" + id_video
video = Video(nombre=new_video['nombre'],
uri=embed_link,
asignatura=asignatura,
curso=curso)
video.save()
return video.to_dict()
def post(self, id_colegio):
data = request.data.decode()
data = json.loads(data)
asignatura = Asignatura()
asignatura.nombre = data['nombre']
institucion = Institucion.objects(id=id_colegio).first()
asignatura.institucion = institucion.id
asignatura.save()
return {'Response': 'exito'}
def get(self):
response = []
asignaturas = Asignatura.objects().all()
for asignatura in asignaturas:
if asignatura.activo:
cursos_lista = []
cursos = Curso.objects(asignatura=asignatura.id).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_asignatura):
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
profesores = []
asignatura = Asignatura.objects(id=id_asignatura).first()
for profesor in Profesor.objects(asignatura=asignatura.id,
activo=True).all():
if profesor.activo:
profesores.append(profesor.to_dict())
return profesores
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
labels = []
data_asistencia = []
data_inasistencia = []
asignatura = Asignatura.objects(id=profesor.asignatura.id).first()
for curso in Curso.objects().all():
if asignatura in curso.asignaturas:
labels.append(curso.nombre)
asistencia_prom = 0
cantidad_asistencia = 0
for asistencia in Asistencia.objects(asignatura=asignatura,
curso=curso):
promedio = 0
cantidad_asistencia = cantidad_asistencia + 1
if len(asistencia.alumnos_presentes) + len(
asistencia.alumnos_presentes) > 0:
promedio = int(
(len(asistencia.alumnos_presentes) /
(len(asistencia.alumnos_presentes) +
len(asistencia.alumnos_presentes))) * 100)
asistencia_prom = asistencia_prom + promedio
if cantidad_asistencia > 0:
asistencia_prom = int(asistencia_prom /
cantidad_asistencia)
data_asistencia.append(asistencia_prom)
data_inasistencia.append(100 - asistencia_prom)
return {
"labels": labels,
"data": [{
'data': data_asistencia,
'label': 'Asistencia'
}]
}
def to_dict(self):
curso = Curso.objects(id=self.curso.id).first()
asignatura = Asignatura.objects(id=self.asignatura.id).first()
alumnos_presentes = []
alumnos_ausentes = []
for alumno in self.alumnos_presentes:
alumno_aux = Alumno.objects(id=alumno.id).first()
alumnos_presentes.append(alumno_aux.to_dict())
for alumno in self.alumnos_ausentes:
alumno_aux = Alumno.objects(id=alumno.id).first()
alumnos_ausentes.append(alumno_aux.to_dict())
return {
"id": str(self.id),
"asignatura": asignatura.to_dict(),
"alumnos_presentes": alumnos_presentes,
"alumnos_ausentes": alumnos_ausentes,
"curso": self.curso.to_dict(),
"fecha": self.fecha.strftime("%Y/%m/%d %H:%M:%S")
}
def post(self):
data = request.data.decode()
data = json.loads(data)
token = request.headers.get('auth_token')
profesor = Profesor.load_from_token(token)
asignatura = Asignatura.objects(id= data['asignatura']).first()
curso_base = CursoBase.objects(id=data['curso_base']).first()
curso = Curso()
curso.nombre = data['nombre']
curso.categoria = curso_base.categoria
for habilidad_base in curso_base.habilidades:
curso.habilidades.append(habilidad_base.id)
for contenido_base in curso_base.contenidos:
contenido = Contenido()
contenido.identificador = contenido_base.identificador
contenido.texto = contenido_base['texto']
for pregunta_base in contenido_base['preguntas']:
pregunta = Pregunta()
pregunta.texto = pregunta_base['texto']
pregunta.numero = pregunta_base['numero']
habilidad = Habilidad.objects(id=pregunta_base['habilidad'].id).first()
pregunta.habilidad = habilidad.id
pregunta.tipo_pregunta = pregunta_base['tipo_pregunta']
for alternativa_base in pregunta_base['alternativas']:
alternativa = Alternativa()
alternativa.texto = alternativa_base['texto']
alternativa.texto_secundario = alternativa_base['texto_secundario']
alternativa.correcta = alternativa_base['correcta']
pregunta.alternativas.append(alternativa)
contenido.preguntas.append(pregunta)
curso.contenidos.append(contenido)
curso.asignatura = asignatura.id
curso.profesor = profesor.id
curso.activo = True
curso.curso_base = curso_base.id
curso.descripcion = data['descripcion']
curso.save()
return {'Response': 'exito', 'id': str(curso.id), 'id_base': str(curso_base.id)}
def get(self, id_asignatura):
args = self.reqparse.parse_args()
token = args.get('auth-token')
alumno = Alumno.load_from_token(token)
apoderado = Apoderado.load_from_token(token)
asignatura = Asignatura.objects(id=id_asignatura).first()
if alumno == None and apoderado == None:
return {'response': 'user_invalid'}, 401
asistencias = []
for asistencia in Asistencia.objects(asignatura=asignatura,
curso=alumno.curso).all():
if alumno in asistencia.alumnos_presentes:
asistencias.append({
"id":
str(asistencia.id),
"fecha":
asistencia.fecha.strftime("%Y/%m/%d %H:%M:%S"),
"presente":
True,
"justificacion":
"Sin justificación"
})
else:
justificacion = "Sin justificación"
if Justificacion.objects(asistencia=asistencia,
alumno=alumno).first() != None:
justificacion = Justificacion.objects(
asistencia=asistencia, alumno=alumno).first().causa
asistencias.append({
"id":
str(asistencia.id),
"fecha":
asistencia.fecha.strftime("%Y/%m/%d %H:%M:%S"),
"presente":
False,
"justificacion":
justificacion
})
return asistencias
from models.cargo import Cargo
from models.plantilla import Plantilla
from models.usuario import Usuario, Administrador, Estudiante, Estructura, Funcionario
from models.tesis import Tesis
#crear roles
'''create role estudiante not identified;
create role administrador not identified;
create role funcionario not identified;
create role estructura not identified;'''
#asignar permisos
#Creo 2 asignaturas
a1 = Asignatura.create("Bases de datos 2")
a2 = Asignatura.create("Bases de datos 1")
# Creo algunos cargos
docente_c = Cargo.create("Docente")
decano_ing_c = Cargo.create("Decano Ingenieria")
rector_c = Cargo.create("Rector")
coordinador_ing_sistemas = Cargo.create("Coordinador ingenieria de sistemas")
#Creo una plantilla y anado una pregunta
pl = Plantilla.create("Plantilla de prueba")
pl.addPregunta("Nueva pregunta")
#Creo usuario administrador
u1 = Usuario.create("Cristian Rojas", "carojasq", "contrasena", "*****@*****.**")
a1 = Administrador.create(u1)