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 User(db.Document):
username = db.StringField(required=True, unique=True)
password = db.StringField(required=True)
phone_number = db.StringField(required=True)
isActivated = db.BooleanField(default=False)
isDriver = db.BooleanField(default=False)
def hash_password(self):
self.password = generate_password_hash(self.password).decode('utf-8')
def check_password(self, password):
return check_password_hash(self.password, password)
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 Alternativa(db.EmbeddedDocument):
texto = db.StringField()
texto_secundario = db.StringField()
correcta = db.BooleanField(default=False)
meta = {'strict': False}
def to_dict(self):
return {"texto": self.texto, "correcta": self.correcta}
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 Asignatura(gj.Document):
nombre = db.StringField(verbose_name="Nombre Asignatura", max_length=200)
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}
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 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 SuperAdmin(db.Document, UserMixin):
email = db.EmailField()
password = db.StringField()
active = db.BooleanField(default=True)
confirmed_at = db.DateTimeField()
created = db.DateTimeField(default=datetime.now)
updated = db.DateTimeField(default=datetime.now)
meta = {'strict': False}
def encrypt_password(self, password_to_encrypt):
self.password = hash_password(password_to_encrypt)
def check_password(self, password_to_check):
return verify_password(self.password, str(password_to_check).strip())
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 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 Categoria(gj.Document):
nombre = db.StringField(verbose_name="Nombre Categoria", max_length=200)
activo = db.BooleanField(default=True)
imagen = db.StringField()
meta = {'strict': False}
def __str__(self):
return self.nombre
def to_dict(self):
return {
"id": str(self.id),
"nombre": self.nombre,
"activo": self.activo,
"imagen": self.imagen
}
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 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 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 Alternativa(db.EmbeddedDocument):
texto = db.StringField()
correcta = db.BooleanField(default=False)
meta = {'strict': False}
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 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 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
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 Profesor(gj.Document):
nombres = db.StringField(max_length=20)
apellido_paterno = db.StringField(max_length=20)
apellido_materno = db.StringField(max_length=20)
email = db.EmailField()
telefono = db.StringField(max_length=12)
password = db.StringField()
password_provisoria = db.StringField(default="no disponible")
direccion = db.EmbeddedDocumentField(Direccion)
rut = db.StringField(max_length=10)
asignatura = db.ReferenceField(Asignatura)
imagen = db.StringField()
activo = db.BooleanField(default=True)
meta = {'strict': False}
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,
"password": self.password,
"direccion": self.direccion.to_dict(),
"rut": self.rut,
"asignatura": self.asignatura.to_dict(),
"imagen": self.imagen
}
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
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 Apoderado(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(max_length=12)
password = db.StringField()
password_provisoria = db.StringField(default="no disponible")
direccion = db.EmbeddedDocumentField(Direccion)
rut = db.StringField(max_length=10)
alumno = db.ReferenceField(Alumno)
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,
"direccion": self.direccion.to_dict(),
"rut": self.rut,
"alumno": self.alumno.to_dict(),
"imagen": self.imagen
}
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
def create_layout_excel(cls):
headers = ["RUT", "Nombres", "Apellido Paterno", "Apellido Materno", "Email",
"Telefono", "Calle", "Numero", "Comuna", "Villa/Depto", "RUN Alumno"]
result_list = [Alumno.export_to_excel()]
return create_excel(result_list, headers, "Formato_apoderados")
# TODO: validar que el rut del alumno sea valido, el rut apoderado y correo con formato correo
@classmethod
def create_from_excel(cls, list_rows):
error_list = [["RUT", "Nombres", "Apellido Paterno", "Apellido Materno", "Email",
"Telefono", "Calle", "Numero", "Comuna", "Villa/Depto", "RUN Alumno", "Error"]]
for apoderado in list_rows:
apoderado = list(apoderado)
print(apoderado)
rut = str(apoderado[0])
if(rut != "None" and validar_rut(rut)):
rut_alumno = str(apoderado[10])
if(rut_alumno != "None" and validar_rut(rut_alumno)):
alumno = Alumno.objects(rut=str(rut_alumno)).first()
if(alumno == None):
apoderado.append("Alumno no existe")
error_list.append(apoderado)
continue
else:
apoderado.append("RUT del alumno no es valido")
error_list.append(apoderado)
continue
if(apoderado[4] == "None" or not(es_correo_valido(apoderado[4]))):
apoderado.append("Correo ingresado no es valido")
error_list.append(apoderado)
continue
direccion = Direccion(calle=apoderado[6], numero=str(
apoderado[7]), comuna=apoderado[8], cas_dep_of=apoderado[9])
apoderadoNuevo = Apoderado(rut=str(apoderado[0]),
nombres=apoderado[1],
apellido_paterno=apoderado[2],
apellido_materno=apoderado[3],
email=apoderado[4],
telefono=str(apoderado[5]),
direccion=direccion, alumno=alumno, imagen="default")
apoderadoNuevo.encrypt_password(str(apoderado[0]))
apoderadoNuevo.save()
else:
apoderado.append("RUT invalido")
error_list.append(apoderado)
if(len(error_list) > 1):
return write_error(error_list, "errores")
return "hecho"
@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 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'
