class FlashesModel(db.Document): __tablename__ = "flashes" flash_id = db.IntField() time = db.StringField( max_length=20) lat = db.FloatField() lon = db.FloatField() region = db.IntField() delay = db.FloatField() # flash_id = db.Column(db.Integer, primary_key=True) # time = db.Column(db.String(20), nullable=False) # lat = db.Column(db.Float, nullable=False) # lon = db.Column(db.Float, nullable=False) # region = db.Column(db.Float, nullable=False) # delay = db.Column(db.Float, nullable=False) @classmethod def find_by_id(cls, flash_id: int) -> "FlashesModel": return cls.query.filter_by(flash_id=flash_id).first() @classmethod def find_by_region(cls, region: int) -> "FlashesModel": return cls.query.filter_by(region=region).first() @classmethod def find_by_lat(cls, lat: int) -> "FlashesModel": return cls.query.filter_by(lat=lat).first() @classmethod def find_by_lon(cls, lon: int) -> "FlashesModel": return cls.query.filter_by(lon=lon).first() @classmethod def find_by_time(cls, time: str) -> "FlashesModel": return cls.query.filter_by(time=time).first() @classmethod def find_all(cls): return(mycol.find()) # return(mydb.collection.find()) # for cls.x in mycol.find(): # return(cls.x) # return cls.query.all() def save_to_db(self) -> None: db.session.add(self) db.session.commit() def delete_from_db(self) -> None: db.session.delete(self) db.session.commit()
class GameRecord(db.Document): game = db.ReferenceField(Game, verbose_name=u'赛事') round = db.IntField(verbose_name=u'轮次') desk_no = db.IntField(verbose_name=u'桌号') red = db.ReferenceField(NameList, verbose_name=u'红方') blue = db.ReferenceField(NameList, verbose_name=u'蓝方') result = db.StringField(choices=[(u'红方胜', u'红方胜'), (u'蓝方胜', u'蓝方胜'), (u'平局', u'平局'), (u'红方弃权', u'红方弃权'), (u'蓝方弃权', u'蓝方弃权')], verbose_name=u'赛果') diff = db.IntField(default=6, verbose_name=u'级差') #级差
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 AnalysisModel(db.Document): keyword = db.StringField(required=True) pos_cnt = db.IntField(required=True) neg_cnt = db.IntField(required=True) datetime = db.StringField(required=True) def __init__(self, keyword, pos_cnt, neg_cnt, datetime, *args, **kwargs): super(db.Document, self).__init__() self.keyword = keyword self.pos_cnt = pos_cnt self.neg_cnt = neg_cnt self.datetime = datetime def json(self): return { 'keyword': self.keyword, 'pos_cnt': self.pos_cnt, 'neg_cnt': self.neg_cnt, 'datetime': self.datetime } @classmethod def find_by_keyword(cls, keyword): return cls.objects(keyword=keyword) def save_to_db(self): self.save() @classmethod def get_all_keywords(cls): return cls.objects().distinct('keyword') @classmethod def get_tweet_count(cls, keyword): pos = cls.objects(keyword=keyword).sum('pos_cnt') neg = cls.objects(keyword=keyword).sum('neg_cnt') return pos + neg @classmethod def get_positive_ratio_by_keyword(cls, keyword): pos = cls.objects(keyword=keyword).sum('pos_cnt') neg = cls.objects(keyword=keyword).sum('neg_cnt') if neg == 0: return 1 return 1.0 * pos / (pos + neg)
class Task(db.Document): id = db.IntField() title = db.StringField() description = db.StringField() done = db.BoolField() @classmethod def find_all(cls) -> List["Task"]: return cls.query.all()
class NameList(db.Document): game = db.ReferenceField(Game, verbose_name=u'赛事') no = db.IntField(unique_with='game', verbose_name=u'赛号') company = db.StringField(verbose_name=u'单位名称') team_no = db.StringField(verbose_name=u'队伍编号') players = db.StringField(verbose_name=u'选手') def __unicode__(self): return u'赛号:%d 选手:%s 单位:%s' % (self.no, self.players, self.company)
class Respuesta(db.EmbeddedDocument): correcta = db.BooleanField(default=False) numero_pregunta = db.IntField() data = db.StringField() meta = {'strict': False} def to_dict(self): return { "correcta": self.correcta, "numero_pregunta": self.numero_pregunta, "data": self.data }
class Colegio(gj.Document): nombre = db.StringField(verbose_name="Nombre Institucion", max_length=200) direccion = db.EmbeddedDocumentField(Direccion) activo = db.BooleanField(default=True) cantidad_estudiantes = db.IntField(default=0) meta = {'strict': False} def to_dict(self): return { "id": str(self.id), "nombre": self.nombre, "cantidad_estudiantes": self.cantidad_estudiantes, "direccion": self.direccion.to_dict() } def to_excel(self): return [str(self.id),self.nombre] def __str__(self): return self.nombre def updateCantEstudiantes(self): from models.alumno import Alumno alumnos = Alumno.objects(colegio=self.id).all() contador = 0 for alumno in alumnos: if alumno.activo: contador= contador+1 self.cantidad_estudiantes = contador return True @classmethod def create_layout_excel(cls): headers = ["Nombre","Calle","Numero","Comuna"] result_list = [] return create_excel(result_list, headers, "Formato_colegios") @classmethod def create_from_excel(cls, list_rows): for colegio in list_rows: direccion = Direccion(calle = colegio[1], numero = str(colegio[2]), comuna = colegio[3]) colegio = Colegio(direccion = direccion, nombre= colegio[0]) colegio.save() return "hecho" @classmethod def export_to_excel(cls): colegios= Colegio.objects().all() result_list_colegios=[["Id. Colegio", "Nombre Colegio"]] for colegio in colegios: result_list_colegios.append(colegio.to_excel()) return result_list_colegios
class Respuesta(db.EmbeddedDocument): correcta = db.BooleanField() numero_pregunta = db.IntField() alternativa = db.StringField() meta = {'strict': False} def to_dict(self): return { "correcta": self.correcta, "numero_pregunta": self.numero_pregunta, "alternativa": self.alternativa }
class Alternativa(db.EmbeddedDocument): texto = db.StringField() texto_secundario = db.StringField() correcta = db.BooleanField(default=False) numero_alternativa = db.IntField(default=0) meta = {'strict': False} def to_dict(self): return{ "texto": self.texto, "texto_secundario": self.texto_secundario, "correcta": self.correcta, "numero_alternativa": self.numero_alternativa, "numero_opcion": self.numero_alternativa }
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 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 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 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 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 Grado(gj.Document): institucion = db.ReferenceField(Institucion) nivel = db.IntField() identificador = db.StringField(max_length=5) activo = db.BooleanField(default=True) profesor = db.ReferenceField(Profesor, required=True) def __str__(self): return str(self.nivel) + "°" + self.identificador def getGrado(self): return str(self.nivel) + "°" + self.identificador def to_dict(self): return { "id": str(self.id), "nivel": self.nivel, "identificador": self.identificador, "activo": self.activo }
class Pregunta(db.EmbeddedDocument): numero_pregunta = db.IntField() topico = db.ReferenceField(Topico) alternativa = db.StringField(choices=ALTERNATIVAS) meta = {'strict': False} def to_dict(self): return { "numero_pregunta": self.numero_pregunta, "topico": self.topico.to_dict(), "alternativa": self.alternativa } @classmethod def create_layout_excel(cls, topicos): headers = ["Numero", "Alternativa Correcta", "Id. Topico"] result_list = [Topico.export_to_excel(topicos)] return create_excel(result_list, headers, "Formato_preguntas") # TODO: validar id del topico y q venga la alternativa entre los valores permitidos @classmethod def create_from_excel(cls, list_rows): list_preguntas = [] for index, pregunta in enumerate(list_rows): try: topico = Topico.objects(id=pregunta[2]).first() if (topico == None): return [] except: return [] if (pregunta[1] == "None" or not (pregunta[1] in ["A", "B", "C", "D", "E"])): return [] alternativa = pregunta[1] preguntaNuevo = Pregunta(numero_pregunta=index + 1, alternativa=alternativa, topico=topico) list_preguntas.append(preguntaNuevo) return list_preguntas
class Seccion(gj.Document): titulo = db.StringField(max_length=30) descripcion = db.StringField() data = db.StringField() imagen = db.StringField() activo = db.BooleanField(default=True) tipo = db.StringField(choices=TIPOS_SECCIONES) posicion = db.IntField() institucion = db.ReferenceField(Institucion) meta = {'strict': False} def __str__(self): return self.titulo def to_dict(self): institucion = "" if self.institucion != None: institucion = self.institucion.to_dict() return { "id": str(self.id), "titulo": self.titulo, "data": self.data, "imagen": self.imagen, "activo": self.activo, "tipo": self.tipo, "institucion": institucion, "posicion": self.posicion } def asignarPosicion(self, id): institucion = Institucion.objects(id=id).first() posicion = 0 for seccion in Seccion.objects(institucion=institucion.id).all(): if seccion.activo: if posicion < seccion.posicion: posicion = seccion.posicion self.posicion = posicion + 1 return True
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 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 DataRecord(db.Document): image = db.StringField(required=True) predict = db.IntField(required=True)
class factionbasics(db.Document): ID: db.IntField() respect: db.IntField() name: db.StringField()
class Alumno(gj.Document): nombres = db.StringField() apellido_paterno = db.StringField(max_length=20) apellido_materno = db.StringField(max_length=20) email = db.EmailField() telefono = db.StringField() password = db.StringField() password_provisoria = db.StringField(default="no disponible") direccion = db.EmbeddedDocumentField(Direccion) colegio = db.ReferenceField(Colegio) rut = db.StringField() sexo = db.StringField(choices=TIPOS_SEXOS) puntaje_ingreso = db.IntField() curso = db.ReferenceField(Curso) imagen = db.StringField() activo = db.BooleanField(default=True) meta = {'strict': False} def __str__(self): return self.nombres def to_dict(self): return { "id": str(self.id), "nombres": self.nombres, "apellido_paterno": self.apellido_paterno, "apellido_materno": self.apellido_materno, "email": self.email, "telefono": self.telefono, "colegio": self.colegio.to_dict(), "direccion": self.direccion.to_dict(), "sexo": self.sexo, "puntaje_ingreso": self.puntaje_ingreso, "curso": self.curso.to_dict(), "rut": self.rut, "imagen": self.imagen } def to_excel(self): return [ self.rut, self.nombres, self.apellido_paterno, self.apellido_materno ] def encrypt_password(self, password_to_encrypt): self.password = generate_password_hash(password_to_encrypt) def check_password(self, password_to_check): print(check_password_hash(self.password, str(password_to_check))) return check_password_hash(self.password, str(password_to_check)) @classmethod def get_by_email_or_username(cls, email_or_usernmane): text_id = email_or_usernmane.lower() if '@' in text_id: return cls.objects.filter(email=text_id).first() return cls.objects.filter(username=text_id).first() @classmethod def get_by_id(cls, user_id): return cls.objects(id=user_id).first() # token alive 10 hours def get_token(self, seconds_live=36000): token = Serializer(current_app.config.get("TOKEN_KEY"), expires_in=seconds_live) return str(token.dumps({'id': str(self.id)})) @classmethod def load_from_token(cls, token): s = Serializer(current_app.config.get("TOKEN_KEY")) if token[0:2] == "b'" and token[-1:] == "'": token = token[2:-1] try: data = s.loads(token) return cls.get_by_id(data['id']) except SignatureExpired: # the token has ben expired return None except BadSignature: # the token ist'n valid return None return None @classmethod # TODO: validar que vengan los id foraneos, el rut y correo con formato correo def create_from_excel(cls, list_rows): error_list = [[ "RUN", "Nombres", "Apellido Paterno", "Apellido Materno", "Puntaje Ingreso", "Sexo", "Email", "Telefono", "Calle", "Numero", "Comuna", "Villa/Depto", "Id. Curso", "Id. Colegio", "Error" ]] for alumno in list_rows: alumno = list(alumno) rut = str(alumno[0]) if (rut != "None" and validar_rut(rut)): try: curso = Curso.objects(id=alumno[12]).first() if (curso == None): alumno.append("Curso no existe") error_list.append(alumno) continue except: alumno.append("Id de curso no es valido") error_list.append(alumno) continue try: colegio = Colegio.objects(id=alumno[13]).first() if (colegio == None): alumno.append("Colegio no existe") error_list.append(alumno) continue except: alumno.append("Id de colegio no es valido") error_list.append(alumno) continue if (alumno[5] == "None" or not (alumno[5] in TIPOS_SEXOS_ARRAY)): alumno.append("Sexo ingresado no es valido") error_list.append(alumno) continue if (alumno[6] == "None" or not (es_correo_valido(alumno[6]))): alumno.append("Correo ingresado no es valido") error_list.append(alumno) continue direccion = Direccion(calle=alumno[8], numero=str(alumno[9]), comuna=alumno[10], cas_dep_of=alumno[11]) alumnoNuevo = Alumno(rut=str(alumno[0]), nombres=alumno[1], apellido_paterno=alumno[2], apellido_materno=alumno[3], sexo=alumno[5], email=alumno[6], telefono=str(alumno[7]), direccion=direccion, colegio=colegio, curso=curso, imagen="default") alumnoNuevo.encrypt_password(str(alumno[0])) if (alumno[4] != None and alumno[4] != ""): alumnoNuevo.puntaje_ingreso = alumno[4] else: alumnoNuevo.puntaje_ingreso = 0 alumnoNuevo.save() else: alumno.append("RUT invalido") error_list.append(alumno) if (len(error_list) > 1): return write_error(error_list, "errores") return "hecho" @classmethod 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") @classmethod def export_to_excel(cls): alumnos = Alumno.objects().all() result_list_alumnos = [[ "RUN", "Nombres", "Apellido Paterno", "Apellido Materno" ]] for alumno in alumnos: result_list_alumnos.append(alumno.to_excel()) return result_list_alumnos @classmethod def create_provisional_pass(cls, user_mail, provisional_pass): admin = cls.get_by_email_or_username(user_mail) admin.password_provisoria = provisional_pass admin.save() return 'hecho'
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 Submission(db.Document, BaseMixin): student = db.ReferenceField(User) point = db.IntField(validation=_validate_point) def __str__(self): return f"{self.student}: {self.point}"