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
