class Conversation(db.Model):
__tablename__ = 'conversations'
conversation_id = db.Column(db.Integer, primary_key=True)
first_user = db.Column(
db.Integer,
ForeignKey('user.user_id', ondelete='CASCADE', onupdate="CASCADE"))
second_user = db.Column(
db.Integer,
ForeignKey('user.user_id', ondelete='CASCADE', onupdate="CASCADE"))
def serialize(self):
return {
'conversation_id': self.conversation_id,
'first_user': self.first_user,
'second_user': self.second_user
}
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 GroupDeliverableRelation(db.Model, Base):
__tablename__ = 'group_deliverable_relation'
group_id = db.Column(db.Integer,
ForeignKey('group_project.group_id',
ondelete='CASCADE',
onupdate="CASCADE"),
primary_key=True)
deliverable_id = db.Column(db.Integer,
ForeignKey('deliverable.deliverable_id',
ondelete='CASCADE',
onupdate="CASCADE"),
primary_key=True)
group = relationship("GroupProject", foreign_keys=[group_id])
deliverable = relationship("Deliverables", foreign_keys=[deliverable_id])
def serialize(self):
return {
"group_id": self.group_id,
"deliverable_id": self.deliverable_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 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 Post(db.Model, Base):
__tablename__ = 'post'
post_id = db.Column(db.Integer, primary_key=True)
post_writer = db.Column(db.Integer,
ForeignKey('user.user_id', onupdate="CASCADE"))
post_owner = db.Column(
db.Integer, ForeignKey('post_owner.owner_id', onupdate="CASCADE"))
post_text = db.Column(db.Text(20000))
def serialize(self):
return {
'post_writer': self.post_writer,
'post_owner': self.post_owner,
'post_text': self.post_text,
'post_id': self.post_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 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 Deliverables_Results(db.Model, Base):
__tablename__ = 'deliverables_results'
deliverable_id = db.Column(db.Integer,
ForeignKey('deliverable.deliverable_id',
ondelete='CASCADE',
onupdate="CASCADE"),
primary_key=True)
user_id = db.Column(db.Integer,
ForeignKey('student.user_id',
ondelete='CASCADE',
onupdate="CASCADE"),
primary_key=True)
mark = db.Column(db.Integer)
def serialize(self):
return {
'deliverable_id': self.deliverable_id,
'user_id': self.user_id,
'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 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 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 Student(db.Model, Base):
__tablename__ = 'student'
user_id = db.Column(db.Integer,
ForeignKey('user.user_id',
ondelete='CASCADE',
onupdate="CASCADE"),
nullable=False,
primary_key=True)
student_year = db.Column(db.Integer, nullable=False)
def serialize(self):
return {
'id': self.user_id,
'student_year': self.student_year,
#'group_project':self.group_project_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 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 Results(db.Model, Base):
__tablename__ = 'results'
student_id = db.Column(db.Integer,
ForeignKey('student.user_id',
ondelete='CASCADE',
onupdate="CASCADE"),
primary_key=True)
exam_id = db.Column(db.Integer,
ForeignKey('exams.exam_id',
ondelete='CASCADE',
onupdate="CASCADE"),
primary_key=True)
mark = db.Column(db.Float, nullable=False)
out_of_mark = db.Column(db.Float, nullable=False)
def serialize(self):
return {
"student_id": self.student_id,
"exam_id": self.exam_id,
"mark": self.mark,
"out_of_mark": self.out_of_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_Questions(db.Model, Base):
__tablename__ = 'student_questions'
student_id = db.Column(
db.Integer,
ForeignKey('student.user_id', ondelete='CASCADE', onupdate="CASCADE"))
question_id = db.Column(
db.Integer,
ForeignKey('questions.question_id',
ondelete='CASCADE',
onupdate="CASCADE"))
student_question_id = db.Column(db.Integer, primary_key=True)
db.UniqueConstraint(student_id, question_id)
def serialize(self):
return {
"question_id": self.question_id,
"student_id": self.student_id,
"student_question_id": self.student_question_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 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 Messages(db.Model):
__tablename__ = 'message'
message_id = db.Column(db.Integer, primary_key=True)
sender_id = db.Column(
db.Integer,
ForeignKey('user.user_id', ondelete='CASCADE', onupdate="CASCADE"))
receiver_id = db.Column(
db.Integer,
ForeignKey('user.user_id', ondelete='CASCADE', onupdate="CASCADE"))
text = db.Column(db.Text)
sent_time = db.Column(db.DateTime)
sender = relationship("User", foreign_keys=[sender_id])
receiver = relationship("User", foreign_keys=[receiver_id])
def serialize(self):
return {
'message_id ': self.message_id,
'sender_id ': self.sender_id,
'receiver_id': self.receiver_id,
'text': self.text,
'sent_time': self.sent_time
}
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 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 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 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 StudentGroupRelation(db.Model, Base):
__tablename__ = 'student_group_relation'
group_id = db.Column(db.Integer, ForeignKey('group_project.group_id', ondelete='CASCADE', onupdate="CASCADE"),
primary_key=True)
student_id = db.Column(db.Integer,
ForeignKey('student.user_id', ondelete='CASCADE', onupdate="CASCADE"),
primary_key=True)
group = relationship("GroupProject", foreign_keys=[group_id])
student = relationship("Student", foreign_keys=[student_id])
def serialize(self):
return {
"group_id": self.group_id,
"student_id": self.student_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 Post_liker_relation(db.Model, Base):
__tablename__ = 'post_liker'
liker_id = db.Column(db.Integer, ForeignKey('user.user_id', onupdate="CASCADE"),
primary_key=True)
post_id = db.Column(db.Integer, ForeignKey('post.post_id', ondelete='CASCADE', onupdate="CASCADE"),
primary_key=True)
created_date = db.Column(db.DateTime, default=datetime.datetime.utcnow)
def serialize(self):
return {
'liker_id': self.liker_id,
'post_id': self.post_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 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 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 Bid(db.Model):
id = db.Column(db.Integer, primary_key=True)
bid = db.Column(db.Float, nullable=False)
uid = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
aid = db.Column(db.Integer, db.ForeignKey('auction.id'), nullable=False)
def __repr__(self):
return '<Bid {self.id} (amount={self.amount!r}\tuser={self.uid}\tauction {self.aid})>'.format(
self=self)
class Student(db.Model, Base):
__tablename__ = 'student'
user_id = db.Column(db.Integer,
ForeignKey('user.user_id',
ondelete='CASCADE',
onupdate="CASCADE"),
nullable=False,
primary_key=True)
student_year = db.Column(db.Integer, nullable=False)
class Listener(db.Model):
id = db.Column(db.Integer, primary_key=True)
date = db.Column(db.DateTime,
nullable=False,
default=datetime.now().astimezone)
uid = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
mid = db.Column(db.Integer, db.ForeignKey('media.id'), nullable=False)
def __repr__(self):
return '<Listener {self.id} (user={self.uid!r}\tmedia={self.mid!r})>'.format(
self=self)
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 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 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()
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()
