class WordCloudModel(db.Document):
keyword = db.StringField(required=True)
related_keywords = db.StringField(required=True)
datetime = db.StringField(required=True)
def __init__(self, keyword, related_keywords, datetime, *args, **kwargs):
super(db.Document, self).__init__()
self.keyword = keyword
self.related_keywords = related_keywords
self.datetime = datetime
def json(self):
return {
'keyword': self.keyword,
'related_keywords': self.related_keywords,
'datetime': self.datetime
}
@classmethod
def find_by_keyword(cls, keyword):
return cls.objects(keyword=keyword)
@classmethod
def aggregate_related_keywords(cls, related_keywords_list):
pass
def save_to_db(self):
self.save()
class EventModel(db.Document):
name = db.StringField(required=True)
organizer = db.StringField()
location = db.StringField()
about = db.StringField()
attendees = db.ListField(default=[])
date = db.DateTimeField()
event_type = db.StringField(default='other',
choices=[
'tech', 'science', 'finance',
'artisan skills', 'health', 'education',
'art', 'other'
])
meta = {'collection': 'events'}
def json(self):
return json.loads(self.to_json())
def save_to_db(self):
self.save()
def delete_from_db(self):
self.delete()
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 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 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()
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 Blockchainid(db.Document):
# metadata
created_at = db.DateTimeField(default=datetime.datetime.now, required=True)
# account data
username = db.StringField(max_length=255, required=True)
profile = db.StringField(required=True)
transfer_address = db.StringField(max_length=255, required=True)
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 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 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 Account(db.Document):
username = db.StringField(required=True, unique=True)
password = db.StringField(required=True, min_length=6)
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 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 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 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 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 Product(db.Document):
meta = {"collection": "products", "queryset_class": MyQuerySet}
name = db.StringField(required=True)
description = db.StringField(required=True)
price = db.DecimalField(0, precision=2, required=True)
location = db.EmbeddedDocumentField(Location, required=True)
dateAdded = db.DateTimeField(default=datetime.now, required=True)
seller = db.LazyReferenceField(User, reverse_delete_rule=2, required=True)
def to_json(self):
data = self.to_mongo()
data["seller"] = loads(self.seller.fetch().to_json())
return json_util.dumps(data)
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 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 Case(db.Document):
date = db.StringField(required=True)
location = db.StringField(required=True)
created_by = db.DocumentField(User)
@classmethod
def find_all(cls) -> List['Case']:
return cls.query.all()
@classmethod
def find_case_by_user(cls, user: User) -> List['Case']:
user_cases = cls.query.filter(cls.created_by == user).all()
return user_cases
def save_case(self) -> None:
db.session.save(self)
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 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 Historial(db.EmbeddedDocument):
fecha = db.DateTimeField(default=datetime.now)
data = db.StringField()
meta = {'strict': False}
def to_dict(self):
return {"fecha": str(self.fecha), "data": self.data}
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 Comuna(db.Document):
nombre = db.StringField()
ciudad = db.ReferenceField(Ciudad)
meta = {'strict': False}
def __str__(self):
return self.nombre
class Direccion(db.EmbeddedDocument):
calle = db.StringField(max_length=50)
numero = db.StringField(max_length=50)
comuna = db.StringField(max_length=50)
cas_dep_of = db.StringField(max_length=50)
meta = {'strict': False}
def __str__(self):
return self.nombre
def to_dict(self):
return {
"calle": self.calle,
"numero": self.numero,
"comuna": self.comuna,
"cas_dep_of": self.cas_dep_of
}
class ItemModel(db.Document):
name = db.StringField()
image = db.URLField()
description = db.StringField()
specifications = db.ListField(db.DictField())
@classmethod
def find_by_name(cls, name):
item = ItemModel.objects(name=name)
if item:
return ItemModel.objects.get(name=name)
def save_to_db(self):
self.save()
def delete_from_db(self):
self.delete()
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 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 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 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
}
