class Course(db.Model, Base):
__tablename__ = 'course'
course_code = db.Column(db.String(7), primary_key=True)
course_name = db.Column(db.String(50), nullable=False)
weekly_hours = db.Column(db.Integer, nullable=False)
group_number = db.Column(db.Integer, nullable=False, unique=True)
max_students = db.Column(db.Integer, nullable=False)
def serialize(self):
return {
'course_code': self.course_code,
'course_name': self.course_name,
'weekly_hours': self.weekly_hours,
'group_number': self.group_number,
'max_students': self.max_students
}
def insert(self):
db.session.add(self)
db.session.commit()
def update(self):
db.session.merge(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
class Exams(db.Model, Base):
__tablename__ = 'exams'
exam_id = db.Column(db.Integer, primary_key=True)
course_id = db.Column(db.String(10), ForeignKey('course.course_code', ondelete='CASCADE', onupdate="CASCADE"),
nullable=False)
exam_duration=db.Column(db.String(50))
exam_marks = db.Column(db.Integer)
def serialize(self):
return {
"exam_id":self.exam_id,
"course_id": self.course_id,
"exam_duration":self.exam_duration,
'exam_marks':self.exam_marks
}
def insert(self):
db.session.add(self)
db.session.commit()
return self.exam_id
def update(self):
db.session.merge(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
class Materials(db.Model, Base):
__tablename__ = 'material'
material_id = db.Column(db.Integer, primary_key=True)
material_name = db.Column(db.String(50), nullable=False)
material_type = db.Column(db.String(50), nullable=False)
downloadable = db.Column(db.Boolean, nullable=False)
course_material = db.Column(db.String(5),
ForeignKey('course.course_code',
ondelete='CASCADE',
onupdate="CASCADE"),
nullable=False)
students_number = db.Column(db.Integer, nullable=False)
def serialize(self):
return {
"material_id": self.material_id,
"material_name": self.material_name,
"material_type": self.material_type,
"downloadable": self.downloadable,
"course_material": self.course_material
}
def insert(self):
db.session.add(self)
db.session.commit()
def update(self):
db.session.merge(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
class Prerequiste(db.Model, Base):
__tablename__ = 'Prerequiste'
course_code = db.Column(db.String(10),
ForeignKey('course.course_code',
ondelete='CASCADE',
onupdate="CASCADE"),
primary_key=True)
pre_course_id = db.Column(db.String(10),
ForeignKey('course.course_code',
ondelete='CASCADE',
onupdate="CASCADE"),
primary_key=True)
def serialize(self):
return {
'course_code': self.course_code,
'pre_course_id': self.pre_course_id
}
def insert(self):
db.session.add(self)
db.session.commit()
def update(self):
db.session.merge(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
class User(db.Model, Base):
__tablename__ = 'user'
user_id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50), nullable=False)
email = db.Column(db.String(50), nullable=False, unique=True)
national_id = db.Column(db.String(50), nullable=False, unique=True)
birthday = db.Column(db.Date, nullable=False)
password = db.Column(db.String(255))
picture = db.Column(db.String(255))
def serialize(self):
return {
'user_id': self.user_id,
'name': self.name,
'email': self.email,
'national_id': self.national_id,
'birthday': str(self.birthday),
'picture': self.picture
}
def insert(self):
db.session.add(self)
db.session.commit()
def update(self):
db.session.merge(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
class Prerequiste(db.Model,Base):
__tablename__ = 'Prerequiste'
course_code = db.Column(db.String(5),ForeignKey('course.course_code',ondelete='CASCADE',onupdate="CASCADE"),primary_key=True)
pre_course_id = db.Column(db.String(5),ForeignKey('course.course_code',ondelete='CASCADE',onupdate="CASCADE"))
class Events(db.Model, Base):
__tablename__ = 'events'
event_id = db.Column(db.Integer, primary_key=True)
event_name = db.Column(db.String(50), nullable=False)
event_date = db.Column(db.DateTime, nullable=False)
course_code = db.Column(db.String(50), ForeignKey('course.course_code', ondelete='CASCADE', onupdate="CASCADE"),
nullable=False)
event_type = db.Column(db.String(50), nullable=False)
event_duration = db.Column(db.Integer, nullable=False)
event_description = db.Column(db.Text)
def serialize(self):
return {
"event_id": self.event_id,
"event_name": self.event_name,
"event_date": json.dumps(self.event_date,indent=4, sort_keys=True,default=str).replace("\"",""),
"course_code": self.course_code,
"event_duration": self.event_duration,
"event_type": self.event_type,
"event_description":self.event_description
}
def insert(self):
db.session.add(self)
db.session.commit()
def update(self):
db.session.merge(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
class Deliverables(db.Model, Base):
__tablename__ = 'deliverable'
deliverable_id = db.Column(db.Integer, primary_key=True)
deliverable_name = db.Column(db.String(50), nullable=False)
deadline = db.Column(db.DateTime, nullable=False)
course_deliverables = db.Column(db.String(5),
ForeignKey('course.course_code',
ondelete='CASCADE',
onupdate="CASCADE"),
nullable=False)
students_number = db.Column(db.Integer, nullable=False)
class Events(db.Model, Base):
__tablename__ = 'events'
event_id = db.Column(db.Integer, primary_key=True)
event_name = db.Column(db.String(50), nullable=False)
event_date = db.Column(db.Date, nullable=False)
course_code = db.Column(db.String(50),
ForeignKey('course.course_code',
ondelete='CASCADE',
onupdate="CASCADE"),
nullable=False)
max_students = db.Column(db.Integer, nullable=False)
class Teaches_Relation(db.Model, Base):
__tablename__ = 'teaches'
professor_id = db.Column(db.Integer,
ForeignKey('professor.user_id',
ondelete='CASCADE',
onupdate="CASCADE"),
primary_key=True)
course_code = db.Column(db.String(7),
ForeignKey('course.course_code',
ondelete='CASCADE',
onupdate="CASCADE"),
primary_key=True)
def serialize(self):
return {
'professor_id': self.professor_id,
'course_code': self.course_code
}
def insert(self):
db.session.add(self)
db.session.commit()
def update(self):
db.session.merge(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
class Learns_Relation(db.Model, Base):
__tablename__ = 'learns'
student_id = db.Column(db.Integer,
ForeignKey('student.user_id',
ondelete='CASCADE',
onupdate="CASCADE"),
primary_key=True)
course_code = db.Column(db.String(10),
ForeignKey('course.course_code',
ondelete='CASCADE',
onupdate="CASCADE"),
primary_key=True)
mid_term_mark = db.Column(db.Float, default=0)
final_exam_mark = db.Column(db.Float, default=0)
def serialize(self):
return {
'student_id': self.student_id,
'course_code': self.course_code,
'mid_term_mark': self.mid_term_mark,
'final_exam_mark': self.final_exam_mark
}
def insert(self):
db.session.add(self)
db.session.commit()
def update(self):
db.session.merge(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
class Student_Answers(db.Model, Base):
__tablename__ = 'student_answers'
student_answer_id = db.Column(db.Integer, primary_key=True)
student_question_id = db.Column(db.Integer, ForeignKey('student_questions.student_question_id', ondelete='CASCADE',
onupdate="CASCADE"))
student_answer = db.Column(db.String(50), nullable=False)
correct_answer = db.Column(db.Boolean)
def serialize(self):
return {
"student_answer_id": self.student_answer_id,
"student_question_id": self.student_question_id,
"student_answer": self.student_answer
}
def insert(self):
db.session.add(self)
db.session.commit()
def update(self):
db.session.merge(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
class GroupCourseRelation(db.Model, Base):
__tablename__ = 'group_course_relation'
group_id = db.Column(db.Integer,
ForeignKey('group_project.group_id',
ondelete='CASCADE',
onupdate="CASCADE"),
primary_key=True)
course_id = db.Column(db.String(7),
ForeignKey('course.course_code',
ondelete='CASCADE',
onupdate="CASCADE"),
primary_key=True)
group = relationship("GroupProject", foreign_keys=[group_id])
course = relationship("Course", foreign_keys=[course_id])
def serialize(self):
return {"group_id": self.group_id, "course_id": self.course_id}
def insert(self):
db.session.add(self)
db.session.commit()
def update(self):
db.session.merge(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
class GroupProject(db.Model, Base):
__tablename__ = 'group_project'
group_id = db.Column(db.Integer, primary_key=True)
group_name = db.Column(db.String(50))
group_description = db.Column(db.Text(20000))
post_owner_id = db.Column(
db.Integer,
ForeignKey('post_owner.owner_id',
onupdate="CASCADE",
ondelete='SET NULL'))
group_pic = db.Column(db.Text(30000))
def serialize(self):
return {
"group_id": self.group_id,
"group_name": self.group_name,
"group_description": self.group_description,
"post_owner_id": self.post_owner_id,
'group_pic': self.group_pic
}
def insert(self):
db.session.add(self)
db.session.commit()
return self.group_id
def update(self):
db.session.merge(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
class Professor(db.Model, Base):
__tablename__ = 'professor'
user_id = db.Column(db.Integer,
ForeignKey('user.user_id',
ondelete='CASCADE',
onupdate="CASCADE"),
nullable=False,
primary_key=True)
scientific_degree = db.Column(db.String(50), nullable=False)
def serialize(self):
return {
'id': self.user_id,
'degree': self.scientific_degree,
}
def insert(self):
db.session.add(self)
db.session.commit()
def update(self):
db.session.merge(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
class Questions(db.Model, Base):
__tablename__ = 'questions'
question_id = db.Column(db.Integer, primary_key=True)
question = db.Column(db.String(500), nullable=False)
mark = db.Column(db.Integer)
exam_id = db.Column(db.Integer, ForeignKey('exams.exam_id', ondelete='CASCADE', onupdate="CASCADE"),
nullable=False)
db.UniqueConstraint(question, exam_id)
def serialize(self):
return {
"question_id": self.question_id,
"question": self.question,
"mark": self.mark,
'exam_id':self.exam_id
}
def insert(self):
db.session.add(self)
db.session.commit()
return self.question_id
def update(self):
db.session.merge(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
class Media(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100), nullable=False)
full_audio = db.Column(db.String(200), nullable=False)
demo_segment = db.Column(db.String(200), nullable=False)
cover = db.Column(db.String(200), nullable=False)
dist_type = db.Column(db.Boolean, nullable=False)
plays = db.Column(db.Integer, nullable=False, default=0)
earnings = db.Column(db.Float, nullable=False, default=0)
uid = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
listeners = db.relationship('Listener',
backref=db.backref('media', lazy='select'),
lazy='select')
def __repr__(self):
return '<Media {self.id} (title={self.title!r}\ttype={self.dist_type})>'.format(
self=self)
class Course(db.Model, Base):
__tablename__ = 'course'
course_code = db.Column(db.String(10), primary_key=True)
course_name = db.Column(db.String(50), nullable=False)
weekly_hours = db.Column(db.Integer, nullable=False)
group_number = db.Column(db.Integer, nullable=False)
max_students = db.Column(db.Integer, nullable=False)
course_description = db.Column(db.Text(30000))
post_owner_id=db.Column(db.Integer,ForeignKey('post_owner.owner_id', onupdate="CASCADE",ondelete='SET NULL'))
course_deadline=db.Column(db.DateTime)
course_pic = db.Column(db.Text(30000), nullable=True)
final = db.Column(db.Integer, nullable=False, default=0)
mid = db.Column(db.Integer, nullable=False, default=0)
def serialize(self):
return {
'course_code': self.course_code,
'course_name': self.course_name,
'weekly_hours': self.weekly_hours,
'group_number': self.group_number,
'max_students': self.max_students,
"course_description":self.course_description,
"post_owner_id":self.post_owner_id,
"course_deadline": json.dumps(
self.course_deadline, default=str).replace("\"", ""),
'course_pic': self.course_pic,
'final': self.final,
'mid': self.mid
}
def insert(self):
db.session.add(self)
db.session.commit()
return self.course_code
def update(self):
db.session.merge(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
class User(db.Model):
id = db.Column(db.Integer,
primary_key=True) # autoincrement=True by default
name = db.Column(db.String(100), nullable=False)
email = db.Column(db.String(200), unique=True, nullable=False)
avatar = db.Column(db.String(200),
nullable=False,
default='images/default-avatar.png')
password = db.Column(db.String(150), nullable=False)
mnemonic = db.Column(db.String(500), nullable=False)
identity = db.Column(db.Integer, nullable=False)
title = db.Column(db.String(100))
subscription = db.Column(db.DateTime)
createdAt = db.Column(db.DateTime,
nullable=False,
default=datetime.now().astimezone)
media = db.relationship('Media',
backref=db.backref('user', lazy='joined'),
lazy='select')
auctions = db.relationship('Auction',
backref=db.backref('user', lazy='joined'),
lazy='select')
owns = db.relationship('Ownership',
backref=db.backref('user', lazy='joined'),
lazy='select')
def __repr__(self):
return '<User {self.id} (name={self.name!r}\temail={self.email!r})>'.format(
self=self)
class Finished(db.Model, Base):
__tablename__ = 'finish'
course_code = db.Column(db.String(5),
ForeignKey('course.course_code',
ondelete='CASCADE',
onupdate="CASCADE"),
primary_key=True)
student_id = db.Column(db.Integer,
ForeignKey('student.user_id',
ondelete='CASCADE',
onupdate="CASCADE"),
primary_key=True)
class Deliver(db.Model, Base):
__tablename__ = 'deliver'
delivers_id = db.Column(db.Integer, primary_key=True)
deliverable_id = db.Column(
db.Integer,
ForeignKey('deliverable.deliverable_id',
ondelete='CASCADE',
onupdate="CASCADE"))
student_id = db.Column(
db.Integer,
ForeignKey('student.user_id', ondelete='CASCADE', onupdate="CASCADE"))
file_type = db.Column(db.String(50))
file_name = db.Column(db.String(500))
student = relationship("Student", foreign_keys=[student_id])
deliverable = relationship("Deliverables", foreign_keys=[deliverable_id])
def serialize(self):
return {
'delivers_id': self.delivers_id,
"file_type": self.file_type,
"file_name": self.file_name,
'deliverable_id': self.deliverable_id,
'student_id': self.student_id
}
def insert(self):
db.session.add(self)
db.session.commit()
return self.delivers_id
def update(self):
db.session.merge(self)
db.session.commit()
return self.serialize()
def delete(self):
db.session.delete(self)
db.session.commit()
class Deliverables(db.Model, Base):
__tablename__ = 'deliverable'
deliverable_id = db.Column(db.Integer, primary_key=True)
deliverable_name = db.Column(db.String(50), nullable=False)
deadline = db.Column(db.DateTime, nullable=False)
description = db.Column(db.Text)
course_deliverables = db.Column(db.String(10),
ForeignKey('course.course_code', ondelete='CASCADE', onupdate="CASCADE"),
nullable=False)
students_number = db.Column(db.Integer,nullable=False)
mark = db.Column(db.Integer, nullable=False)
def serialize(self):
return {
'deliverable_id': self.deliverable_id,
'deliverable_name': self.deliverable_name,
'deadline': self.deadline,
'description': self.description,
"course_deliverables": self.course_deliverables, # this is the course code foreign key that references course table
"students_number": self.students_number,
"mark": self.mark
}
def insert(self):
db.session.add(self)
db.session.commit()
def update(self):
db.session.merge(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
class Professor(db.Model,Base):
__tablename__ = 'professor'
user_id = db.Column(db.Integer, ForeignKey('user.user_id',ondelete='CASCADE',onupdate="CASCADE"), nullable=False, primary_key=True)
scientific_degree = db.Column(db.String(50),nullable=False)
def serialize(self):
return {
'id': self.user_id,
'name': self.name
}
def get(self,user_id):
user = self.query.filter_by(user_id=user_id).one()
return user.serialize()
