class CursoBase(gj.Document):
nombre = db.StringField(verbose_name="Nombre curso", max_length=200)
descripcion = db.StringField()
fecha_creacion = db.DateTimeField(default=datetime.now)
contenidos = db.ListField(db.EmbeddedDocumentField(Contenido))
institucion = db.ReferenceField(Institucion)
categoria = db.ReferenceField(Categoria)
habilidades = db.ListField(db.ReferenceField(Habilidad))
imagen = db.StringField()
meta = {'strict': False}
def __str__(self):
return self.nombre
def to_dict(self):
contenidos = []
for contenido in self.contenidos:
contenidos.append(contenido.to_dict())
habilidades = []
for habilidad in self.habilidades:
habilidades.append(habilidad.to_dict())
return{
"id": str(self.id),
"nombre": self.nombre,
"descripcion": self.descripcion,
"fecha_creacion": str(self.fecha_creacion),
"contenidos": contenidos,
"imagen": self.imagen,
"categoria": self.categoria.to_dict(),
"habilidades": habilidades
}
class UserModel(db.Document):
first_name = db.StringField(required=True)
last_name = db.StringField(required=True)
email_address = db.EmailField(required=True, unique=True)
password = db.StringField(required=True)
organizations_following = db.ListField(default=[])
users_following = db.ListField(default=[])
services = db.ListField(default=[])
meta = {'collection': 'users'}
def json(self):
return json.loads(self.to_json())
def save_to_db(self):
self.save()
def delete_from_db(self):
self.delete()
def add_service(self, service_object):
self.services.append(service_object)
def follow_organization(self, organization_object):
self.organizations_following.append(organization_object)
def follow_user(self, user_object):
self.users_following.append(user_object)
@classmethod
def find_by_email(cls, email_address):
return UserModel.objects(email_address=email_address).first()
class User(db.Document):
name = db.StringField(required=True)
email = db.EmailField(required=True, unique=True, min_length=6)
password = db.StringField(required=True, min_length=6)
profile_pic = db.StringField(default="")
list_of_products = db.ListField(db.ReferenceField('List', reverse_delete_rule=db.PULL))
friends = db.ListField()
def hash_password(self):
self.password = generate_password_hash(self.password).decode('utf8')
def check_password(self, password):
return check_password_hash(self.password, password)
class EventModel(db.Document):
name = db.StringField(required=True)
organizer = db.StringField()
location = db.StringField()
about = db.StringField()
attendees = db.ListField(default=[])
date = db.DateTimeField()
event_type = db.StringField(default='other',
choices=[
'tech', 'science', 'finance',
'artisan skills', 'health', 'education',
'art', 'other'
])
meta = {'collection': 'events'}
def json(self):
return json.loads(self.to_json())
def save_to_db(self):
self.save()
def delete_from_db(self):
self.delete()
class Evento(gj.Document):
title = db.StringField(max_length=256)
start = db.DateTimeField()
backgroundColor = db.StringField()
textColor = db.StringField(default="white")
cursos = db.ListField(db.ReferenceField(Curso))
activo = db.BooleanField(default=False)
eliminado = db.BooleanField(default=False)
def setStart(self):
mes = str(self.start.month)
dia = str(self.start.day)
if len(str(self.start.month)) is 1:
mes = "0" + str(self.start.month)
if len(str(self.start.day)) is 1:
dia = "0" + str(self.start.day)
return str(self.start.year) + "-" + mes + "-" + dia
def to_dict(self):
cursos = []
for curso in self.cursos:
cursos.append(curso.nombre)
return {
"id": str(self.id),
"title": self.title,
"start": self.setStart(),
"backgroundColor": self.backgroundColor,
"textColor": self.textColor,
"cursos": cursos,
"activo": self.activo
}
class Pregunta(db.EmbeddedDocument):
tipo_pregunta = db.StringField(choices=TIPOS_PREGUNTA)
texto = db.StringField()
alternativas = db.ListField(db.EmbeddedDocumentField(Alternativa))
habilidad = db.ReferenceField(Habilidad, requiered=True)
indice = db.IntField()
meta = {'strict': False}
def to_dict(self):
habilidad = ""
if self.habilidad != None:
habilidad = self.habilidad.to_dict()
alternativas = []
contador = 0
for alternativa in self.alternativas:
numero_alternativa = contador
alternativas.append(alternativa.to_dict())
contador = contador + 1
return {
"texto": self.texto,
"tipo_pregunta": self.tipo_pregunta,
"alternativas": alternativas,
"habilidad": habilidad,
"indice": self.indice
}
class Evaluacion(gj.Document):
alumno = db.ReferenceField(Alumno)
curso = db.ReferenceField(Curso)
acierto = db.IntField(default=0)
creado = db.DateTimeField(default=datetime.now)
actualizado = db.DateTimeField(default=datetime.now)
respuestas = db.ListField(db.EmbeddedDocumentField(Respuesta))
json = db.StringField()
meta = {'strict': False}
def save(self, *args):
self.actualizado = datetime.now()
super().save()
def to_dict(self):
contenidos_respuesta = []
for respuesta in self.respuestas:
contenidos_respuesta.append(respuesta.to_dict())
return {
"id": str(self.id),
"alumno": self.alumno.to_dict(False),
"recurso": str(self.curso.id),
"recurso_nombre": self.curso.nombre,
"respuestas": contenidos_respuesta,
"acierto": self.acierto
}
class CursoBase(gj.Document):
nombre = db.StringField(verbose_name="Nombre curso", max_length=200)
descripcion = db.StringField()
fecha_creacion = db.DateTimeField(default=datetime.now)
contenidos = db.ListField(db.EmbeddedDocumentField(Contenido))
categoria = db.ReferenceField(Categoria, requiered=True)
habilidades = db.ListField(db.ReferenceField(Habilidad))
imagen = db.StringField()
# juego
android = db.URLField(help_text="Url para android")
ios = db.URLField(help_text="Url para ios")
meta = {'strict': False}
def __str__(self):
return self.nombre
def to_dict(self):
contenidos = []
contador = 0
for contenido in self.contenidos:
contenido.indentificador = contador
contenidos.append(contenido.to_dict())
contador = contador + 1
habilidades = []
for habilidad in self.habilidades:
habilidades.append(habilidad.to_dict())
categoria = {}
if self.categoria:
categoria = self.categoria.to_dict()
self.save()
return {
"id": str(self.id),
"nombre": self.nombre,
"descripcion": self.descripcion,
"fecha_creacion": str(self.fecha_creacion),
"contenidos": contenidos,
"imagen": self.imagen,
"categoria": categoria,
"habilidades": habilidades
}
class Song(db.DynamicEmbeddedDocument):
upvote_users = db.ListField(db.StringField())
def to_json(self):
res = super(Song, self).to_json(self)
import json
obj = json.loads(res)
obj.upvote_users = 3
return json.dumps(obj)
class User(db.Document, UserMixin):
email = db.StringField(max_length=255)
password = db.StringField(max_length=255)
active = db.BooleanField(default=True)
confirmed_at = db.DateTimeField()
roles = db.ListField(db.ReferenceField(Role), default=[])
def __unicode__(self):
return self.email
def __init__(self, email, password, nom, prenom, rue, cp, ville, tags):
self.email = db.EmailField(max_length=30)
self.password = db.StringField(max_length=100)
self.nom = db.StringField(max_length=30)
self.prenom = db.StringField(max_length=30)
self.rue = db.StringField(max_length=30)
self.cp = db.StringField(max_length=30)
self.ville = db.StringField(max_length=30)
self.tags = db.ListField(max_length=30)
class Curso(gj.Document):
nombre = db.StringField(verbose_name="Nombre curso", max_length=200)
fecha_creacion = db.DateTimeField(default=datetime.now)
contenidos = db.ListField(db.EmbeddedDocumentField(Contenido))
asignatura = db.ReferenceField(Asignatura)
institucion = db.ReferenceField(Institucion)
profesor = db.ReferenceField(Profesor)
categoria = db.ReferenceField(Categoria)
alumnos = db.ListField(db.ReferenceField(Alumno))
activo = db.BooleanField(default=True)
version = db.StringField(default="1.0")
curso_base = db.ReferenceField(CursoBase)
descripcion = db.StringField()
aprobacion = db.IntField(default=0)
imagen = db.StringField()
habilidades = db.ListField(db.ReferenceField(Habilidad))
meta = {'strict': False}
def __str__(self):
return self.nombre
def to_dict(self, full=True):
data = {
"id": str(self.id),
"nombre": self.nombre,
"fecha_creacion": str(self.fecha_creacion),
"profesor": self.profesor.to_dict(),
"activo": self.activo,
"version": self.version,
"descripcion": self.descripcion,
"imagen": self.imagen,
"curso_base": self.curso_base.to_dict(),
"categoria": self.categoria.to_dict()
}
if full:
data.update({
"contenidos": [x.to_dict() for x in self.contenidos],
"asignatura": self.asignatura.to_dict(),
"alumnos": [x.to_dict() for x in self.alumnos],
"aprobacion": self.aprobacion,
"curso_base": self.curso_base.to_dict(),
"habilidades": [x.to_dict() for x in self.habilidades]
})
return data
class Asistencia(db.Document):
fecha = db.DateTimeField(default=datetime.now)
curso = db.ReferenceField(Curso)
asignatura = db.ReferenceField(Asignatura)
alumnos_presentes = db.ListField(db.ReferenceField(Alumno))
alumnos_ausentes = db.ListField(db.ReferenceField(Alumno))
def to_dict_short(self):
return {
"id": str(self.id),
"asignatura": self.asignatura.nombre,
"alumnos_presentes": len(self.alumnos_presentes),
"alumnos_ausentes": len(self.alumnos_ausentes),
"curso": self.curso.nombre,
"fecha": self.fecha.strftime("%Y/%m/%d %H:%M:%S"),
}
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")
}
class Contenido(db.EmbeddedDocument):
texto = db.StringField()
preguntas = db.ListField(db.EmbeddedDocumentField(Pregunta))
identificador = db.IntField()
meta = {'strict': False}
def to_dict(self):
preguntas = []
for pregunta in self.preguntas:
preguntas.append(pregunta.to_dict())
return {
"texto": self.texto,
"preguntas": preguntas,
"identificador": self.identificador
}
class ItemModel(db.Document):
name = db.StringField()
image = db.URLField()
description = db.StringField()
specifications = db.ListField(db.DictField())
@classmethod
def find_by_name(cls, name):
item = ItemModel.objects(name=name)
if item:
return ItemModel.objects.get(name=name)
def save_to_db(self):
self.save()
def delete_from_db(self):
self.delete()
class Alerta(db.Document):
tipo = db.StringField(choices=TIPOS_ALERTA)
alumno = db.ReferenceField(Alumno)
asignatura = db.ReferenceField(Asignatura)
data = db.StringField(max_length=250)
fecha = db.DateTimeField(default=datetime.now)
historial = db.ListField(db.EmbeddedDocumentField(Historial))
def to_dict(self):
return {
"id": str(self.id),
"alumno": self.alumno.to_dict(),
"data": self.data,
"fecha": self.fecha.strftime("%m/%d/%Y %H:%M:%S"),
"tipo": self.tipo,
"asignatura": self.asignatura.to_dict()
}
class Inscripcion(gj.Document):
alumno = db.ReferenceField(Alumno)
curso = db.ReferenceField(Curso)
estado = db.StringField(choices=TIPOS_ESTADO_INSCRIPCION)
historial = db.ListField(db.EmbeddedDocumentField(Historial))
meta = {'strict': False}
def to_dict(self):
historiales = []
for historial in self.historial:
historiales.append(historial.to_dict())
return {
"id": str(self.id),
"alumno": self.alumno.to_dict(),
"curso": self.curso.to_dict(),
"estado": self.estado,
"historial": historiales
}
class Curso(gj.Document):
nombre = db.StringField(verbose_name="Nombre curso", max_length=200)
cantidad_estudiantes = db.IntField(default=0)
asignaturas = db.ListField(db.ReferenceField(Asignatura))
activo = db.BooleanField(default=True)
meta = {'strict': False}
def __str__(self):
return self.nombre
def to_excel(self):
return [str(self.id), self.nombre]
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 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
@classmethod
def export_to_excel(cls):
cursos = Curso.objects().all()
result_list_cursos = [["Id. Curso", "Nombre Curso"]]
for curso in cursos:
result_list_cursos.append(curso.to_excel())
return result_list_cursos
class Evaluacion(gj.Document):
alumno = db.ReferenceField(Alumno)
institucion = db.ReferenceField(Institucion)
curso = db.ReferenceField(Curso)
respuestas = db.ListField(db.EmbeddedDocumentField(Respuesta))
acierto = db.IntField(default=0)
meta = {'strict': False}
def to_dict(self):
contenidos_respuesta = []
for respuesta in self.respuestas:
contenidos_respuesta.append(respuesta.to_dict())
return {
"id": str(self.id),
"alumno": self.alumno.to_dict(),
"curso": self.curso.to_dict(),
"respuestas": contenidos_respuesta,
"acierto": self.acierto
}
class Institucion(gj.Document):
nombre = db.StringField(verbose_name="Nombre Institucion", max_length=200)
fecha_creacion = db.DateTimeField(default=datetime.now)
logo = db.StringField()
identificador = db.StringField()
cursos_base = db.ListField(db.ReferenceField('CursoBase'))
meta = {'strict': False}
def __str__(self):
return self.nombre
def to_dict(self):
return {
"id": str(self.id),
"nombre": self.nombre,
"fecha_creacion": str(self.fecha_creacion),
"logo": self.logo,
"identificador": self.identificador
}
class Contenido(db.EmbeddedDocument):
texto = db.StringField()
preguntas = db.ListField(db.EmbeddedDocumentField(Pregunta))
identificador = db.IntField()
imagen = db.StringField(default="default")
meta = {'strict': False}
def to_dict(self):
preguntas = []
contador = 0
for pregunta in self.preguntas:
pregunta.indice = contador
preguntas.append(pregunta.to_dict())
contador = contador + 1
return {
"texto": self.texto,
"preguntas": preguntas,
"identificador": self.identificador,
"imagen": self.imagen
}
class Assignment(db.Document, BaseMixin):
name = db.StringField(min_length=3, max_length=25, required=True)
description = db.StringField(max_length=100, required=True)
link = db.URLField()
topic = db.ReferenceField(Topic, default=None)
submissions = db.ListField(db.ReferenceField(Submission))
def __str__(self):
return f"{self.name}"
def update_all(self, **kwargs):
self.name = kwargs["name"]
self.description = kwargs["description"]
if kwargs["topic"]:
self.topic = Topic.find(id=kwargs["topic"])
self.save()
def add(self, submission):
self.submissions = list(self.submissions) + [submission]
self.save()
class Pregunta(db.EmbeddedDocument):
texto = db.StringField()
tipo_pregunta = db.StringField()
alternativas = db.ListField(db.EmbeddedDocumentField(Alternativa))
habilidad = db.ReferenceField(Habilidad)
numero = db.IntField()
imagen = db.StringField()
meta = {'strict': False}
def to_dict(self):
habilidad = ""
if self.habilidad != None:
habilidad = self.habilidad.to_dict()
alternativas = []
for alternativa in self.alternativas:
alternativas.append(alternativa.to_dict())
return {
"texto": self.texto,
"tipo_pregunta": self.tipo_pregunta,
"alternativas": alternativas,
"habilidad": habilidad,
"numero": self.numero
}
class OrganizationModel(db.Document):
name = db.StringField(required=True, unique=True)
owner = db.StringField()
address = db.StringField()
about = db.StringField()
followers = db.ListField(default=[])
image_url = db.StringField()
organization_type = db.StringField(default='other', choices=['business', 'school', 'hospital', 'orphanage', 'other'])
meta = {'collection': 'organizations'}
def json(self):
return json.loads(self.to_json())
def save_to_db(self):
self.save()
def delete_from_db(self):
self.delete()
@classmethod
def find_by_name(cls, name):
return OrganizationModel.objects(name=name).first()
class Session(db.DynamicDocument):
name = db.StringField(required=True)
password = db.StringField()
created_on = db.DateTimeField(default=datetime.utcnow)
songs = db.ListField(db.EmbeddedDocumentField('Song'))
messages = db.ListField(db.StringField())
class Prueba(gj.Document):
nombre = db.StringField(max_length=250)
cantidad_preguntas = db.IntField()
asignatura = db.ReferenceField(Asignatura)
fecha = db.DateTimeField(default=datetime.now)
preguntas = db.ListField(db.EmbeddedDocumentField(Pregunta))
topicos = db.ListField(db.ReferenceField(Topico))
tipo = db.StringField(choices=TIPOS_PRUEBA)
visible = db.BooleanField(default=False)
activo = db.BooleanField(default=True)
puntaje_base = db.IntField(default=0)
meta = {'strict': False}
def __str__(self):
return self.nombre
def to_dict(self):
topicos = []
for topico in self.topicos:
topicos.append(topico.to_dict())
preguntas = []
for pregunta in self.preguntas:
preguntas.append(pregunta.to_dict())
return {
"id": str(self.id),
"nombre": self.nombre,
"cantidad_preguntas": self.cantidad_preguntas,
"asignatura": self.asignatura.to_dict(),
"fecha": self.fecha.strftime("%Y/%m/%d %H:%M:%S"),
"tipo": self.tipo,
"topicos": topicos,
"preguntas": preguntas,
"puntaje_base": self.puntaje_base,
"visible": self.visible
}
#TODO: validar que id de la prueba
@classmethod
def load_preguntas(cls, lista, prueba_id):
try:
prueba = Prueba.objects(id=prueba_id).first()
if (prueba == None):
return {"error": "Prueba no encontrada"}
except:
return {"error": "Error en el id de la prueba"}
listado_preguntas = Pregunta.create_from_excel(lista)
if (len(listado_preguntas) == 0):
return {
"error":
"Problema al cargar las preguntas de la prueba, favor revisar excel"
}
prueba.preguntas = listado_preguntas
prueba.cantidad_preguntas = len(lista)
prueba.save()
return {"Response": "Prueba creada con exito"}
@classmethod
def list_to_dict(cls, lista):
result_list = []
for element in lista:
result_list.append(element.to_dict())
return result_list
@classmethod
def update_visible(cls, id_prueba):
prueba = Prueba.objects(id=id_prueba).first()
prueba.visible = not prueba.visible
prueba.save()
return "Campo visible actualizado"
class List(db.Document):
list_title = db.StringField(required=True)
cover_image_url = db.StringField()
private = db.BooleanField(default=False)
products = db.ListField(db.ReferenceField('Product'))
added_by = db.ReferenceField('User')
class Curso(gj.Document):
nombre = db.StringField(verbose_name="Nombre curso", max_length=200)
fecha_creacion = db.DateTimeField(default=datetime.now)
contenidos = db.ListField(db.EmbeddedDocumentField(Contenido))
asignatura = db.ReferenceField(Asignatura)
institucion = db.ReferenceField(Institucion)
profesor = db.ReferenceField(Profesor)
categoria = db.ReferenceField(Categoria)
alumnos = db.ListField(db.ReferenceField(Alumno))
activo = db.BooleanField(default=True)
version_actual = db.BooleanField(default=True)
publicado = db.BooleanField(default=False)
eliminado = db.BooleanField(default=False)
version = db.IntField(default=1)
curso_base = db.ReferenceField(CursoBase, reverse_delete_rule=3)
descripcion = db.StringField()
aprobacion = db.IntField( default=0 )
imagen = db.StringField()
habilidades = db.ListField(db.ReferenceField(Habilidad))
clon_padre = db.ReferenceField('Curso')
meta = {'strict': False }
def __str__(self):
return self.nombre
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 to_dict(self, full=True):
data = {
"id": str(self.id),
"nombre": self.nombre,
"fecha_creacion": str(self.fecha_creacion),
"activo": self.activo,
"eliminado": self.eliminado,
"publicado": self.publicado,
"version": self.version,
"descripcion": self.descripcion,
"imagen": self.imagen,
"curso_base": self.curso_base.to_dict()
}
if self.profesor:
data['profesor'] = self.profesor.to_dict()
if self.categoria:
data['categoria'] = self.categoria.to_dict()
if full:
clon_padre = {}
if self.clon_padre != None:
clon_padre = self.clon_padre.to_dict()
data.update({
"contenidos": [x.to_dict() for x in self.contenidos],
"alumnos": [x.to_dict() for x in self.alumnos],
"aprobacion": self.aprobacion,
"curso_base": self.curso_base.to_dict(),
"habilidades": [x.to_dict() for x in self.habilidades],
"clon_padre": clon_padre,
"version_actual": self.version_actual
})
if self.asignatura:
data['asignatura'] = self.asignatura.to_dict()
return data
class Evaluacion(gj.Document):
alumno = db.ReferenceField(Alumno)
prueba = db.ReferenceField(Prueba)
cantidad_buenas = db.IntField()
cantidad_malas = db.IntField()
cantidad_omitidas = db.IntField()
puntaje = db.IntField()
fecha = db.DateTimeField(default=datetime.now)
respuestas = db.ListField(db.EmbeddedDocumentField(Respuesta))
meta = {'strict': False}
def to_dict(self):
respuestas = []
for respuesta in self.respuestas:
respuestas.append(respuesta.to_dict())
return {
"id": str(self.id),
"alumno": self.alumno.to_dict(),
"prueba": self.prueba.to_dict(),
"cantidad_buenas": self.cantidad_buenas,
"cantidad_malas": self.cantidad_malas,
"cantidad_omitidas": self.cantidad_omitidas,
"puntaje": self.puntaje,
"fecha": self.fecha.strftime("%Y/%m/%d %H:%M:%S"),
"respuestas": respuestas
}
#TODO: validar si existen los objetos asociados
@classmethod
def evaluar_prueba(cls, alumno_id, body):
prueba_id = body["prueba_id"]
listado_respuestas = body["respuestas"]
prueba = Prueba.objects(id=prueba_id).first()
alumno = Alumno.objects(id=alumno_id).first()
print(prueba_id)
print("prueba: ", prueba)
evaluacion = Evaluacion()
cantidad_buenas = 0
cantidad_malas = 0
cantidad_omitidas = 0
evaluacion.alumno = alumno
evaluacion.prueba = prueba
for pregunta in prueba.preguntas:
respuesta = Respuesta()
respuesta.numero_pregunta = pregunta.numero_pregunta
if listado_respuestas[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 listado_respuestas[str(pregunta.numero_pregunta)].upper(
) == pregunta.alternativa.upper():
cantidad_buenas = cantidad_buenas + 1
respuesta.correcta = True
else:
cantidad_malas = cantidad_malas + 1
respuesta.correcta = False
respuesta.alternativa = str(listado_respuestas[str(
pregunta.numero_pregunta)].upper())
else:
if listado_respuestas[str(
pregunta.numero_pregunta)].upper() == "CORRECTA":
cantidad_buenas = cantidad_buenas + 1
respuesta.correcta = True
if listado_respuestas[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'}
@classmethod
def list_to_dict(cls, lista):
result_list = []
for element in lista:
result_list.append(element.to_dict())
return result_list
@classmethod
def get_pruebas_no_respondidas(cls, alumno_id, asignatura_id):
ensayos = Prueba.objects(asignatura=asignatura_id,
visible=True,
tipo='ENSAYO').all()
talleres = Prueba.objects(asignatura=asignatura_id,
visible=True,
tipo='TALLER').all()
pruebas = list(ensayos) + list(talleres)
pruebas_no_respondidas = []
for prueba in pruebas:
evaluacion = Evaluacion.objects(alumno=alumno_id,
prueba=prueba.id).first()
if evaluacion == None:
pruebas_no_respondidas.append(prueba)
return Prueba.list_to_dict(pruebas_no_respondidas)
class Classroom(db.Document, BaseMixin):
name = db.StringField(min_length=3, max_length=25, required=True)
description = db.StringField(max_length=100, default="")
creator = db.ReferenceField(User)
topics = db.ListField(db.ReferenceField(Topic))
materials = db.ListField(db.ReferenceField(Material))
assignments = db.ListField(db.ReferenceField(Assignment))
teachers = db.ListField(db.ReferenceField(User))
students = db.ListField(db.ReferenceField(User))
def __str__(self):
return f"{self.name}"
def add_student(self, user):
if user in self.students:
raise EnrollmentExists(f"Student with email {user.email} exists")
updated_students = list(self.students)
updated_students.append(user)
self.students = updated_students
self.save()
def remove_student(self, **by):
user = User.find(**by)
if not user:
raise NotFound("User not found")
if user in self.students:
i = self.students.index(user)
self.students = self.students[:i] + \
self.students[i + 1:]
self.save()
return user
else:
return None
def add_teacher(self, user):
if user in self.teachers:
raise EnrollmentExists(f"Teacher with email {user.email} exists")
updated_teachers = list(self.teachers)
updated_teachers.append(user)
self.teachers = updated_teachers
self.save()
def remove_teacher(self, **by):
user = User.find(**by)
if not user:
raise NotFound("User not found")
if user in self.teachers:
i = self.teachers.index(user)
self.teachers = self.teachers[:i] + \
self.teachers[i + 1:]
self.save()
return user
else:
return None
def add_material(self, material):
self.materials = list(self.materials) + [material]
self.save()
def remove_material(self, material):
i = self.materials.index(material)
self.materials = self.materials[:i] + self.materials[i + 1:]
self.save()
return material
def add_assignment(self, assignment):
self.assignments = list(self.assignments) + [assignment]
self.save()
def remove_assignment(self, assignment):
i = self.assignments.index(assignment)
self.assignments = self.assignments[:i] + self.assignments[i + 1:]
self.save()
return assignment
