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 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 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 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 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 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 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 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 Song(db.DynamicEmbeddedDocument): upvote_users = db.ListField(db.StringField()) def to_json(self): res = super(Song, self).to_json(self) import json obj = json.loads(res) obj.upvote_users = 3 return json.dumps(obj)
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
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 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 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 Contenido(db.EmbeddedDocument): texto = db.StringField() preguntas = db.ListField(db.EmbeddedDocumentField(Pregunta)) identificador = db.IntField() meta = {'strict': False} def to_dict(self): preguntas = [] for pregunta in self.preguntas: preguntas.append(pregunta.to_dict()) return { "texto": self.texto, "preguntas": preguntas, "identificador": self.identificador }
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 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 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 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 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 Contenido(db.EmbeddedDocument): texto = db.StringField() preguntas = db.ListField(db.EmbeddedDocumentField(Pregunta)) identificador = db.IntField() imagen = db.StringField(default="default") meta = {'strict': False} def to_dict(self): preguntas = [] contador = 0 for pregunta in self.preguntas: pregunta.indice = contador preguntas.append(pregunta.to_dict()) contador = contador + 1 return { "texto": self.texto, "preguntas": preguntas, "identificador": self.identificador, "imagen": self.imagen }
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 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 OrganizationModel(db.Document): name = db.StringField(required=True, unique=True) owner = db.StringField() address = db.StringField() about = db.StringField() followers = db.ListField(default=[]) image_url = db.StringField() organization_type = db.StringField(default='other', choices=['business', 'school', 'hospital', 'orphanage', 'other']) meta = {'collection': 'organizations'} def json(self): return json.loads(self.to_json()) def save_to_db(self): self.save() def delete_from_db(self): self.delete() @classmethod def find_by_name(cls, name): return OrganizationModel.objects(name=name).first()
class Session(db.DynamicDocument): name = db.StringField(required=True) password = db.StringField() created_on = db.DateTimeField(default=datetime.utcnow) songs = db.ListField(db.EmbeddedDocumentField('Song')) messages = db.ListField(db.StringField())
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 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 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 Evaluacion(gj.Document): alumno = db.ReferenceField(Alumno) prueba = db.ReferenceField(Prueba) cantidad_buenas = db.IntField() cantidad_malas = db.IntField() cantidad_omitidas = db.IntField() puntaje = db.IntField() fecha = db.DateTimeField(default=datetime.now) respuestas = db.ListField(db.EmbeddedDocumentField(Respuesta)) meta = {'strict': False} def to_dict(self): respuestas = [] for respuesta in self.respuestas: respuestas.append(respuesta.to_dict()) return { "id": str(self.id), "alumno": self.alumno.to_dict(), "prueba": self.prueba.to_dict(), "cantidad_buenas": self.cantidad_buenas, "cantidad_malas": self.cantidad_malas, "cantidad_omitidas": self.cantidad_omitidas, "puntaje": self.puntaje, "fecha": self.fecha.strftime("%Y/%m/%d %H:%M:%S"), "respuestas": respuestas } #TODO: validar si existen los objetos asociados @classmethod def evaluar_prueba(cls, alumno_id, body): prueba_id = body["prueba_id"] listado_respuestas = body["respuestas"] prueba = Prueba.objects(id=prueba_id).first() alumno = Alumno.objects(id=alumno_id).first() print(prueba_id) print("prueba: ", prueba) evaluacion = Evaluacion() cantidad_buenas = 0 cantidad_malas = 0 cantidad_omitidas = 0 evaluacion.alumno = alumno evaluacion.prueba = prueba for pregunta in prueba.preguntas: respuesta = Respuesta() respuesta.numero_pregunta = pregunta.numero_pregunta if listado_respuestas[str(pregunta.numero_pregunta)] == "": cantidad_omitidas = cantidad_omitidas + 1 respuesta.correcta = False if prueba.tipo != "TAREA": respuesta.alternativa = "O" else: if prueba.tipo != "TAREA": if listado_respuestas[str(pregunta.numero_pregunta)].upper( ) == pregunta.alternativa.upper(): cantidad_buenas = cantidad_buenas + 1 respuesta.correcta = True else: cantidad_malas = cantidad_malas + 1 respuesta.correcta = False respuesta.alternativa = str(listado_respuestas[str( pregunta.numero_pregunta)].upper()) else: if listado_respuestas[str( pregunta.numero_pregunta)].upper() == "CORRECTA": cantidad_buenas = cantidad_buenas + 1 respuesta.correcta = True if listado_respuestas[str( pregunta.numero_pregunta)].upper() == "INCORRECTA": cantidad_malas = cantidad_malas + 1 respuesta.correcta = False evaluacion.respuestas.append(respuesta) evaluacion.cantidad_buenas = cantidad_buenas evaluacion.cantidad_malas = cantidad_malas evaluacion.cantidad_omitidas = cantidad_omitidas evaluacion.puntaje = int(( (850 - prueba.puntaje_base) / len(prueba.preguntas)) * cantidad_buenas + prueba.puntaje_base) evaluacion.save() return {'Response': '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 get_pruebas_no_respondidas(cls, alumno_id, asignatura_id): ensayos = Prueba.objects(asignatura=asignatura_id, visible=True, tipo='ENSAYO').all() talleres = Prueba.objects(asignatura=asignatura_id, visible=True, tipo='TALLER').all() pruebas = list(ensayos) + list(talleres) pruebas_no_respondidas = [] for prueba in pruebas: evaluacion = Evaluacion.objects(alumno=alumno_id, prueba=prueba.id).first() if evaluacion == None: pruebas_no_respondidas.append(prueba) return Prueba.list_to_dict(pruebas_no_respondidas)
class Classroom(db.Document, BaseMixin): name = db.StringField(min_length=3, max_length=25, required=True) description = db.StringField(max_length=100, default="") creator = db.ReferenceField(User) topics = db.ListField(db.ReferenceField(Topic)) materials = db.ListField(db.ReferenceField(Material)) assignments = db.ListField(db.ReferenceField(Assignment)) teachers = db.ListField(db.ReferenceField(User)) students = db.ListField(db.ReferenceField(User)) def __str__(self): return f"{self.name}" def add_student(self, user): if user in self.students: raise EnrollmentExists(f"Student with email {user.email} exists") updated_students = list(self.students) updated_students.append(user) self.students = updated_students self.save() def remove_student(self, **by): user = User.find(**by) if not user: raise NotFound("User not found") if user in self.students: i = self.students.index(user) self.students = self.students[:i] + \ self.students[i + 1:] self.save() return user else: return None def add_teacher(self, user): if user in self.teachers: raise EnrollmentExists(f"Teacher with email {user.email} exists") updated_teachers = list(self.teachers) updated_teachers.append(user) self.teachers = updated_teachers self.save() def remove_teacher(self, **by): user = User.find(**by) if not user: raise NotFound("User not found") if user in self.teachers: i = self.teachers.index(user) self.teachers = self.teachers[:i] + \ self.teachers[i + 1:] self.save() return user else: return None def add_material(self, material): self.materials = list(self.materials) + [material] self.save() def remove_material(self, material): i = self.materials.index(material) self.materials = self.materials[:i] + self.materials[i + 1:] self.save() return material def add_assignment(self, assignment): self.assignments = list(self.assignments) + [assignment] self.save() def remove_assignment(self, assignment): i = self.assignments.index(assignment) self.assignments = self.assignments[:i] + self.assignments[i + 1:] self.save() return assignment