class Question(db.Model):
__tablename__ = 'questions'
def __init__(self, title, text):
self.title = title
self.text = text
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(50), nullable=False)
text = db.Column(db.String(500), nullable=False)
timestamp = db.Column(db.DateTime(),
nullable=False,
server_default=func.now())
topic_id = db.Column(db.Integer,
db.ForeignKey('topics.id'),
nullable=False)
topic = db.relationship('Topic', uselist=False, back_populates='questions')
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
user = db.relationship('User', back_populates='questions')
answers = db.relationship('Answer',
back_populates='question',
order_by=Answer.id)
def serialize(self):
return {'id': self.id, 'title': self.title, 'text': self.text, \
'timestampStr': self.timestamp.strftime('%d/%m/%Y, %H:%M:%S')}
class Project(db.Model):
"""Project Class contains link to the user that interact with this project,
the top level tasks related to id"""
id = db.Column(db.Integer, primary_key=True)
changed_at = db.Column(
db.DateTime(), default=datetime.now(), onupdate=datetime.now())
name = db.Column(db.String(80))
description = db.Column(db.String(250))
tasks = db.relationship('Task', secondary=project_tasks, lazy='subquery',
backref=db.backref('project', lazy=True))
users = db.relationship('User', secondary=project_users, lazy='subquery',
backref=db.backref('project', lazy=True))
def add_task(self, name, description, end_time):
"""Adds a new Task to this Project"""
self.tasks.append(
Task(name=name, description=description, end_time=end_time)
)
db.session.update(self)
db.session.commit()
def add_user(self, em_usname):
"""Adds existing user to thihs project"""
user = User.query.filter_by(email=em_usname).first()
if not user:
user = User.query.filter_by(username=em_usname).first()
if user:
self.users.append(user)
db.session.update(self)
db.session.commit()
else:
raise Exception()
class Task(db.Model):
__tablename__ = 'task'
"""Task class contains subTasks"""
id = db.Column(db.Integer, primary_key=True)
changed_at = db.Column(
db.DateTime(), default=datetime.now(), onupdate=datetime.now())
name = db.Column(db.String(80))
description = db.Column(db.String(80))
end_time = db.Column(db.Date())
supertask = db.Column(db.Integer, db.ForeignKey('task.id'))
tasks = db.relationship('Task', cascade="all", backref=db.backref(
"parent", remote_side='Task.id'))
questionnaires = db.relationship(
'Questionnaire', backref='taks', lazy=True)
class Grade(db.Model):
__tablename__ = 'grades'
value = db.Column(db.Integer, primary_key=True)
timestamp = db.Column(db.DateTime(), server_default=func.now())
user_id = db.Column(db.Integer,
db.ForeignKey('users.id'),
primary_key=True)
user = db.relationship('User', back_populates='grades')
answers = db.relationship('Answer',
secondary=AnswerGrade,
back_populates='grades')
def serialize(self):
return {
'value': self.value,
'timestampStr': self.timestamp,
'userId': self.user_id
}
class Comment(db.Model):
__tablename__='comments'
def __init__(self, text, answer_id, user_id):
self.text = text
self.answer_id = answer_id
self.user_id = user_id
id = db.Column(db.Integer, primary_key=True)
text = db.Column(db.String(500), nullable=False)
timestamp = db.Column(db.DateTime(), nullable=False, server_default=func.now())
answer_id = db.Column(db.Integer, db.ForeignKey('answers.id'), nullable=False)
answer = db.relationship('Answer', back_populates='comments')
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
user = db.relationship('User', back_populates='comments')
def serialize(self):
return {'id': self.id, 'text': self.text, 'timestampStr': self.timestamp, \
'answerId': self.answer_id, 'userId': self.user_id }
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
changed_at = db.Column(
db.DateTime(), default=datetime.now(), onupdate=datetime.now())
email = db.Column(db.String(80), unique=True, nullable=False)
name = db.Column(db.String(80), unique=True, nullable=False)
password = db.Column(db.String(80), nullable=False)
tasks = db.relationship('Task', secondary=user_tasks, lazy='subquery',
backref=db.backref('users', lazy=True))
def add_task(self, id):
task = Task.query.filter_by(id=id).first()
if task:
self.tasks.append(task)
db.session.update(self)
db.session.commit()
else:
raise Exception()
def get_project_grid(self, n):
grid = []
for i in range(0, len(self.project), n):
grid.append(self.project[i:i + n])
return grid
def get_index_data(self):
tasks = []
projects = []
for count, task in enumerate(sorted(self.tasks, key=(lambda x: x.end_time))):
if count >= 5:
break
else:
tasks.append(task)
for count, project in enumerate(sorted(self.project, key=(lambda x: x.name))):
if count >= 5:
break
else:
projects.append(project)
return {'tasks': tasks, 'projects': projects}
class Answer(db.Model):
__tablename__ = 'answers'
def __init__(self, text, question_id, user_id, is_pinned, grade):
self.text = text
self.question_id = question_id
self.user_id = user_id
self.is_pinned = is_pinned
self.average_grade = grade
id = db.Column(db.Integer, primary_key=True)
text = db.Column(db.String(500), nullable=False)
is_pinned = db.Column(db.Boolean)
average_grade = db.Column(db.Float)
timestamp = db.Column(db.DateTime(),
nullable=False,
server_default=func.now())
question_id = db.Column(db.Integer,
db.ForeignKey('questions.id'),
nullable=False)
question = db.relationship('Question', back_populates='answers')
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
user = db.relationship('User', back_populates='answers')
comments = db.relationship('Comment', back_populates='answer')
images = db.relationship('Image', back_populates='answer')
grades = db.relationship('Grade',
secondary=AnswerGrade,
back_populates='answers')
def serialize(self):
return {'id': self.id, 'text': self.text, 'isPinned': self.is_pinned, 'averageGrade': self.average_grade, \
'timestampStr': self.timestamp, 'questionId': self.question_id, 'userId': self.user_id, \
'grades': [x.serialize() for x in self.grades] }