class UserModel(db.Document):
first_name = db.StringField(required=True)
last_name = db.StringField(required=True)
email_address = db.EmailField(required=True, unique=True)
password = db.StringField(required=True)
organizations_following = db.ListField(default=[])
users_following = db.ListField(default=[])
services = db.ListField(default=[])
meta = {'collection': 'users'}
def json(self):
return json.loads(self.to_json())
def save_to_db(self):
self.save()
def delete_from_db(self):
self.delete()
def add_service(self, service_object):
self.services.append(service_object)
def follow_organization(self, organization_object):
self.organizations_following.append(organization_object)
def follow_user(self, user_object):
self.users_following.append(user_object)
@classmethod
def find_by_email(cls, email_address):
return UserModel.objects(email_address=email_address).first()
def __init__(self, email, password, nom, prenom, rue, cp, ville, tags):
self.email = db.EmailField(max_length=30)
self.password = db.StringField(max_length=100)
self.nom = db.StringField(max_length=30)
self.prenom = db.StringField(max_length=30)
self.rue = db.StringField(max_length=30)
self.cp = db.StringField(max_length=30)
self.ville = db.StringField(max_length=30)
self.tags = db.ListField(max_length=30)
class 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 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 User(db.Document):
meta = {"collection": "users", "queryset_class": MyQuerySet}
email = db.EmailField(required=True, unique=True)
password = db.StringField(required=True)
role = db.StringField(required=True, choices=("user", "admin"))
def to_json(self):
data = self.to_mongo()
del data["password"]
return json_util.dumps(data)
def hashPassword(self):
self.password = generate_password_hash(self.password).decode("utf8")
def checkPassword(self, password):
return check_password_hash(self.password, password)
class User(db.Document, BaseMixin):
name = db.StringField(min_length=2, max_length=25)
email = db.EmailField(unique=True)
password = db.StringField(min_length=5, max_length=1024)
def __repr__(self):
return f"<User (name={self.name}, email={self.email})>"
def __str__(self):
return f"{self.name} - {self.email}"
def generate_jwt_token(self):
identity = dumps({
"id": str(self.id),
"name": self.name,
"email": self.email,
})
return {
"access_token": create_access_token(identity, fresh=True),
"refresh_token": create_refresh_token(identity)
}
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 Email(db.Document):
# metadata
created_at = db.DateTimeField(default=datetime.datetime.now, required=True)
# account data
address = db.EmailField(required=True, unique=True)
email_list = db.StringField(max_length=255, required=True)
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'
