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 Product(db.Document): product_name = db.StringField(required=True) url = db.StringField(required=True) product_image = db.StringField() price = db.FloatField(required=True) added_by = db.ReferenceField('User') in_list = db.ReferenceField('List')
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 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 Justificacion(db.Document): fecha = db.DateTimeField(default=datetime.now) asistencia = db.ReferenceField(Asistencia) alumno = db.ReferenceField(Alumno) causa = db.StringField(max_length=200) activo = db.BooleanField(default=True) def to_dict(self): return { "id": str(self.id), "asistencia": self.asistencia.to_dict_short(), "alumno": self.alumno.to_dict(), "causa": self.causa, "fecha": self.fecha.strftime("%Y/%m/%d %H:%M:%S") }
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 Topico(gj.Document): nombre = db.StringField(verbose_name="Nombre Topico", max_length=200) asignatura = db.ReferenceField(Asignatura) activo = db.BooleanField(default=True) meta = {'strict': False} def __str__(self): return self.nombre def to_dict(self): return { "id": str(self.id), "asignatura": self.asignatura.to_dict(), "nombre": self.nombre } def to_excel(self): return [str(self.id), self.nombre, self.asignatura.to_dict()["nombre"]] @classmethod def export_to_excel(cls, topicos): result_list_topicos = [["Id. Topico", "Nombre Topico", "Asignatura"]] for topico in topicos: result_list_topicos.append(topico.to_excel()) return result_list_topicos
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 Comuna(db.Document): nombre = db.StringField() ciudad = db.ReferenceField(Ciudad) meta = {'strict': False} def __str__(self): return self.nombre
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 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 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 ObservacionProfesor(gj.Document): titulo = db.StringField(max_length=30) contenido = db.StringField(max_length=200) anonimo = db.StringField(choices=ANONIMATO) alumno = db.ReferenceField(Alumno) profesor = db.ReferenceField(Profesor) fecha = db.DateTimeField(default=datetime.now) def to_dict(self): return{ "id": str(self.id), "titulo": self.titulo, "contenido": self.contenido, "anonimo": self.anonimo, "alumno": self.alumno.to_dict(), "profesor": self.profesor.to_dict(), "fecha": self.fecha.strftime("%Y/%m/%d %H:%M:%S") }
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 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
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 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 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 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 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 Asignatura(gj.Document): nombre = db.StringField(verbose_name="Nombre Asignatura", max_length=200) institucion = db.ReferenceField(Institucion) activo = db.BooleanField(default=True) meta = {'strict': False} def __str__(self): return self.nombre def to_dict(self): return { "id": str(self.id), "nombre": self.nombre, "activo": self.activo }
class Material(db.Document, BaseMixin): name = db.StringField(min_length=3, max_length=100, required=True) description = db.StringField(max_length=100, default="") topic = db.ReferenceField(Topic, default=None) content = db.StringField(required=True) def __str__(self): return f"{self.name}" def update_all(self, **kwargs): self.name = kwargs["name"] self.description = kwargs["description"] self.content = kwargs["content"] if kwargs["topic"]: self.topic = Topic.find(id=kwargs["topic"]) self.save()
class Observacion(gj.Document): titulo = db.StringField(max_length=30) contenido = db.StringField(max_length=200) tipo = db.StringField(choices=TIPOS_OBSERVACION) nombre_personal = db.StringField(max_length=30) alumno = db.ReferenceField(Alumno) fecha = db.DateTimeField(default=datetime.now) def to_dict(self): return{ "id": str(self.id), "titulo": self.titulo, "contenido": self.contenido, "tipo": self.tipo, "nombre_personal": self.nombre_personal, "alumno": self.alumno.to_dict(), "fecha": self.fecha.strftime("%Y/%m/%d %H:%M:%S") }
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 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 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 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 Alumno(gj.Document, UserMixin): nombres = db.StringField() apellido_paterno = db.StringField(max_length=20) apellido_materno = db.StringField(max_length=20) email = db.EmailField() telefono = db.StringField(max_length=20) nombre_usuario = db.StringField(max_length=20) password = db.StringField(max_length=255) matricula = db.StringField(max_length=20) institucion = db.ReferenceField(Institucion) grado = db.ReferenceField(Grado) imagen = db.StringField() activo = db.BooleanField(default=True) primera_vez = db.BooleanField(default=True) meta = {'strict': False} def __str__(self): return self.nombres def to_dict(self): if self.grado == None: return { "id": str(self.id), "nombres": self.nombres, "apellido_paterno": self.apellido_paterno, "apellido_materno": self.apellido_materno, "email": self.email, "telefono": self.telefono, "nombre_usuario": self.nombre_usuario, "matricula": self.matricula, #"grado": self.grado.to_dict(), "imagen": self.imagen, "activo": self.activo, "primera_vez": self.primera_vez } else: return { "id": str(self.id), "nombres": self.nombres, "apellido_paterno": self.apellido_paterno, "apellido_materno": self.apellido_materno, "email": self.email, "telefono": self.telefono, "nombre_usuario": self.nombre_usuario, "matricula": self.matricula, "grado": self.grado.to_dict(), "imagen": self.imagen, "activo": self.activo, "primera_vez": self.primera_vez } def encrypt_password(self, password_to_encrypt): self.password = generate_password_hash(password_to_encrypt) def check_password(self, password_to_check): return check_password_hash(self.password, str(password_to_check).strip()) @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_SALT"), 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_SALT")) 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