class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50), nullable=False)
password = db.Column(db.String(50), nullable=False)
def __repr__(self):
return f'User : {self.id} , {self.name}'
class DiscussionThread(db.Model):
__tablename__ = 'discussionthreads'
id = db.Column(db.Integer, primary_key=True)
course_id = db.Column(db.Integer, db.ForeignKey('courses.id'))
title = db.Column(db.String())
details = db.Column(db.String())
posts = db.relationship('DiscussionPost', backref='quiz_response')
class MedicalRecord(db.Model):
__tablename__ = 'medical_records'
id = db.Column(db.Integer, primary_key=True)
patient_id = db.Column(db.Integer,
db.ForeignKey('patients.id'),
nullable=False)
doctor_id = db.Column(db.Integer,
db.ForeignKey('users.id'),
nullable=False)
findings_id = db.Column(db.Integer,
db.ForeignKey('findings.id'),
nullable=False)
lab_exam_id = db.Column(db.Integer,
db.ForeignKey('lab_exams.id'),
nullable=False)
date = db.Column(db.DateTime, nullable=False, default=datetime.now)
height = db.Column(db.String(7), nullable=False)
weight = db.Column(db.String(7), nullable=False)
temperature = db.Column(db.String(7), nullable=False)
paid = db.Column(db.Boolean, nullable=False, default=False)
# patient = db.relationship('MedicalRecord',
# back_populates='medical_records')
findings = db.relationship('Findings',
backref='medical_records',
cascade='all, delete')
symptoms = db.relationship('Symptom',
backref='medical_records',
cascade='all, delete')
lab_exam = db.relationship('LabExam',
backref='medical_records',
cascade='all, delete')
doctor = db.relationship('User', backref='medical_records')
class Attachment(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String())
ext = db.Column(db.String(10))
link = db.Column(db.String())
coursenote_id = db.Column(db.Integer, db.ForeignKey('coursenotes.id'))
assignment_id = db.Column(db.Integer, db.ForeignKey('assignments.id'))
submission_id = db.Column(db.Integer, db.ForeignKey('submission.id'))
discussionpost_id = db.Column(db.Integer,
db.ForeignKey('discussionposts.id'))
request_id = db.Column(db.Integer, db.ForeignKey('request.id'))
def __init__(self,
name,
ext,
link,
coursenote_id=None,
assignment_id=None,
submission_id=None,
request_id=None,
discussionpost_id=None):
self.name = name
self.ext = ext
self.link = link
self.coursenote_id = coursenote_id
self.assignment_id = assignment_id
self.submission_id = submission_id
self.request_id = request_id
self.discussionpost_id = discussionpost_id
class Course(db.Model):
__tablename__ = 'courses'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String())
details = db.Column(db.String())
prof_id = db.Column(db.Integer,
db.ForeignKey('professors.id'),
nullable=False)
course_code = db.Column(db.String(), unique=True)
branches = db.relationship('Branch',
secondary=branch_helper,
backref=db.backref('courses'))
can_apply = db.Column(db.Boolean)
courseNotes = db.relationship('courseNote',
backref='Course',
order_by="desc(courseNote.time)")
assignments = db.relationship('Assignment',
backref='Course',
order_by="desc(Assignment.time)")
requests = db.relationship('Request', backref='course')
quizzes = db.relationship('Quiz', backref='course')
def __init__(
self,
name,
course_code,
details,
prof_id,
can_apply,
):
self.name = name
self.course_code = course_code
self.details = details
self.prof_id = prof_id
self.can_apply = can_apply
class Student(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50), nullable=False)
department = db.Column(db.String(50), nullable=False)
section = db.Column(db.String(10), nullable=False)
def __repr__(self):
return f'Student : {self.id} , {self.name}'
class CBCExam(db.Model):
__tablename__ = 'cbc_exams'
id = db.Column(db.Integer, primary_key=True)
red_blood_cell_count = db.Column(db.String(10))
white_blood_cell_count = db.Column(db.String(10))
platelet_count = db.Column(db.String(10))
hemoglobin = db.Column(db.String(10))
hematocrit = db.Column(db.String(10))
class WebsiteContent(db.Model):
__tablename__ = 'WebsiteContent'
id = db.Column(db.Integer, primary_key=True)
category = db.Column(db.String())
headline = db.Column(db.String())
sub_headline = db.Column(db.String())
article = db.Column(db.String())
nutshell = db.Column(db.String())
blurb = db.Column(db.String())
pullout = db.Column(db.String())
author = db.Column(db.String())
author_description = db.Column(db.String())
number = db.Column(db.Integer)
volume = db.Column(db.Integer)
status = db.Column(db.Integer)
created_by = db.Column(db.String())
created_date = db.Column('created_date', db.DateTime)
def __init__(self, category, sub_headline, article, nutshell, blurb,
pullout, author, author_description, number, volume,
created_by, status, headline, created_date):
self.category = category
self.sub_headline = sub_headline
self.article = article
self.nutshell = nutshell
self.blurb = blurb
self.pullout = pullout
self.author = author
self.author_description = author_description
self.number = number
self.volume = volume
self.status = status
self.created_by = created_by
self.headline = headline
self.created_date = created_date
def __repr__(self):
return '<id {}>'.format(self.id)
def serialize(self):
return {
'id': self.id,
'category': self.category,
'sub_headline': self.sub_headline,
'article': self.article,
'nutshell': self.nutshell,
'blurb': self.blurb,
'pullout': self.pullout,
'author': self.author,
'author_description': self.author_description,
'number': self.number,
'volume': self.volume,
'status': self.status,
'created_by': self.created_by,
'headline': self.headline,
'created_date': self.created_date
}
class Teacher(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50), nullable=False)
department = db.Column(db.String(50), nullable=False)
specialization = db.Column(db.String(100), nullable=False)
experience = db.Column(db.Integer, nullable=False)
def __repr__(self):
return f'Teacher : {self.id} , {self.name}'
class DiscussionPost(db.Model):
__tablename__ = 'discussionposts'
id = db.Column(db.Integer, primary_key=True)
discussion_id = db.Column(db.Integer,
db.ForeignKey('discussionthreads.id'))
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
title = db.Column(db.String())
details = db.Column(db.String())
timeofpost = db.Column(db.DateTime, nullable=False, default=datetime.now)
attachments = db.relationship('Attachment', backref='post')
class Question(db.Model):
__tablename__ = 'questions'
id = db.Column(db.Integer, primary_key=True)
quiz_id = db.Column(db.Integer, db.ForeignKey('quizzes.id'))
question = db.Column(db.String(), nullable=False)
options = db.relationship('Option', backref='question')
ans = db.Column(db.String(), nullable=False)
marks = db.Column(db.Integer, nullable=False, default=1)
is_multicorrect = db.Column(db.Boolean, default=False)
responses = db.relationship('quizQuestionResponse', backref='question')
is_partial = db.Column(db.Boolean, default=False)
class User(db.Model, UserMixin):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(50), unique=True, nullable=False)
name = db.Column(db.String(50), nullable=False)
position = db.Column(db.String(50), nullable=False)
password = db.Column(db.String(255), nullable=False)
patient_id = db.Column(db.Integer,
db.ForeignKey('patients.id'),
nullable=False,
default=0)
class Result(db.Model):
id = db.Column(db.Integer, primary_key=True)
section = db.Column(db.String(5), nullable=False)
marks = db.Column(db.Integer, nullable=False)
grade = db.Column(db.String(10), nullable=False)
entered_by = db.Column(db.Integer, db.ForeignKey('teacher.id'))
obtained_by = db.Column(db.Integer, db.ForeignKey('student.id'))
course = db.Column(db.Integer, db.ForeignKey('course.id'))
def __repr__(self):
return f'Result : {self.id} , {self.marks}'
class courseNote(db.Model):
__tablename__='coursenotes'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100))
details = db.Column(db.String(100))
time=db.Column(db.DateTime,nullable=False,default=datetime.now)
attachments=db.relationship('Attachment',backref='coursenote')
course_id = db.Column(db.Integer, db.ForeignKey('courses.id'))
def __init__(self,title,details,course_id):
self.title=title
self.details=details
self.course_id=course_id
class Submission(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100))
details = db.Column(db.String(100))
time = db.Column(db.DateTime, nullable=False, default=datetime.now)
attachments = db.relationship('Attachment', backref='submissions')
assignment_id = db.Column(db.Integer, db.ForeignKey('assignments.id'))
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
def __init__(self, title, details, assignment_id,user_id):
self.title = title
self.details = details
self.assignment_id = assignment_id
self.user_id=user_id
class Course(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50), nullable=False)
crd_hrs = db.Column(db.Integer)
no_of_student_taken = db.Column(db.Integer, default=0)
status = db.Column(db.String(10))
assign_to = db.Column(db.Integer, db.ForeignKey('teacher.id'))
enrollments = db.relationship('Student',
secondary=Enrollments,
backref=db.backref('courses'))
def __repr__(self):
return f'Course : {self.id} , {self.name}'
class Professor(db.Model, UserMixin):
__tablename__ = 'professors'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String())
email = db.Column(db.String(64), unique=True, index=True)
branch_id = db.Column(db.Integer, db.ForeignKey('branches.id'))
courses = db.relationship('Course', backref='professor', lazy=True)
password_hash = db.Column(db.String(128))
def __init__(self, name, email, password, branch_id):
self.email = email
self.name = name
self.password_hash = generate_password_hash(password)
self.branch_id = branch_id
class Request(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
course_id = db.Column(db.Integer, db.ForeignKey('courses.id'))
title = db.Column(db.String(100))
details = db.Column(db.String(100))
time = db.Column(db.DateTime, nullable=False, default=datetime.now)
attachments = db.relationship('Attachment', backref='request')
status = db.Column(db.Integer,default=0)#0 for pending 1 for accepted 2 for declined
def __init__(self, user_id, course_id,title,details):
self.user_id = user_id
self.course_id = course_id
self.title = title
self.details = details
pass
class Symptom(db.Model):
__tablename__ = 'symptoms'
id = db.Column(db.Integer, primary_key=True)
medical_record_id = db.Column(db.Integer,
db.ForeignKey('medical_records.id'),
nullable=False)
symptom = db.Column(db.String(100), nullable=False)
class Assignment(db.Model):
__tablename__ = 'assignments'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String())
details = db.Column(db.String())
time = db.Column(db.DateTime, nullable=False, default=datetime.now)
attachments = db.relationship('Attachment', backref='assignment')
submissions = db.relationship('Submission', backref='assignment')
deadline = db.Column(db.DateTime)
course_id = db.Column(db.Integer, db.ForeignKey('courses.id'))
def __init__(self, title, details, deadline, course_id):
self.title = title
self.details = details
self.deadline = deadline
self.course_id = course_id
class LabExam(db.Model):
__tablename__ = 'lab_exams'
id = db.Column(db.Integer, primary_key=True)
cbc_exam_id = db.Column(db.Integer,
db.ForeignKey('cbc_exams.id'),
nullable=False)
stool_exam = db.Column(db.String(10))
cbc_exam = db.relationship('CBCExam',
backref='lab_exams',
cascade='delete')
class User(db.Model, UserMixin):
__tablename__ = 'users'
name = db.Column(db.String(100), nullable=False)
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100))
email = db.Column(db.String(64), unique=True, index=True)
password_hash = db.Column(db.String(128))
year = db.Column(db.Integer())
branch_id = db.Column(db.Integer,
db.ForeignKey('branches.id'),
nullable=False)
courses = db.relationship('Course',
secondary=course_helper,
backref=db.backref('students'))
submissions = db.relationship('Submission', backref='user')
requests = db.relationship('Request', backref='user')
quiz_responses = db.relationship('QuizResponse', backref='user')
def __init__(self, name, email, password, year, branch_id):
self.name = name
self.email = email
self.password_hash = generate_password_hash(password)
self.year = year
self.branch_id = branch_id
def to_dict(self):
return {
'id': self.id,
'Name': self.name,
'E-Mail': self.email,
'Year': self.year,
'Branch': self.branch.name
}
def check_password(self, password):
return check_password_hash(self.password_hash, password)
@property
def requested_courses(self):
req_courses = []
for request in self.requests:
req_courses.append(request.course)
return req_courses
class Branch(db.Model):
__tablename__='branches'
id= db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), nullable=False)
students= db.relationship('User', backref='branch', lazy=True)
professors= db.relationship('Professor', backref='branch', lazy=True)
def __init__(self,name):
self.name = name
def __repr__(self)-> str:
return self.name
class Contact(db.Model):
__tablename__ = 'Contact'
id = db.Column(db.Integer, primary_key=True)
organization = db.Column(db.String())
title = db.Column(db.String())
firstName = db.Column(db.String())
lastName = db.Column(db.String())
cellPhone = db.Column(db.String())
workPhone = db.Column(db.String())
email = db.Column(db.String())
description = db.Column(db.String())
remark = db.Column(db.String())
created_at = db.Column('created_at', db.DateTime)
def __init__(self, organization, title, firstName, lastName, cellPhone,
workPhone, email, description, remark):
self.organization = organization
self.title = title
self.firstName = firstName
self.lastName = lastName
self.cellPhone = cellPhone
self.workPhone = workPhone
self.email = email
self.description = description
self.remark = remark
self.created_at = datetime.utcnow()
def __repr__(self):
return '<id {}>'.format(self.id)
def serialize(self):
return {
'id': self.id,
'organization': self.organization,
'title': self.title,
'firstName': self.firstName,
'lastName': self.lastName,
'cellPhone': self.cellPhone,
'workPhone': self.workPhone,
'email': self.email,
'description': self.description,
'remark': self.remark,
'created_at': self.created_at
}
class Column(db.Model):
__tablename__ = 'Column'
id = db.Column(db.Integer, primary_key=True)
headline = db.Column(db.String())
content = db.Column(db.String())
category = db.Column(db.String())
excerpt = db.Column(db.String())
date = db.Column(db.String())
writtenBy = db.Column(db.String())
def __init__(self, headline, content, category, excerpt, date, writtenBy):
self.headline = headline
self.content = content
self.category = category
self.excerpt = excerpt
self.date = date
self.writtenBy = writtenBy
def __repr__(self):
return '<id {}>'.format(self.id)
def serialize(self):
return {
'id': self.id,
'headline': self.headline,
'content': self.content,
'category': self.category,
'excerpt': self.excerpt,
'date': self.date,
'writtenBy': self.writtenBy
}
class EdtionBudget(db.Model):
__tablename__ = 'EdtionBudget'
id = db.Column(db.Integer, primary_key=True)
total_page = db.Column(db.String())
number = db.Column(db.String())
volume = db.Column(db.String())
total_advertisement = db.Column(db.String())
no_of_color_pages = db.Column(db.String())
created_by = db.Column(db.String())
created_at = db.Column('created_at', db.DateTime)
def __init__(self, total_page, number, volume, total_advertisement,
no_of_color_pages):
self.total_page = total_page
self.number = number
self.volume = volume
self.total_advertisement = total_advertisement
self.no_of_color_pages = no_of_color_pages
self.created_at = datetime.utcnow()
def __repr__(self):
return '<id {}>'.format(self.id)
def serialize(self):
return {
'id': self.id,
'total_page': self.total_page,
'number': self.number,
'volume': self.volume,
'total_advertisement': self.total_advertisement,
'no_of_color_pages': self.no_of_color_pages,
'created_by': self.created_by,
'created_at': self.created_at
}
class MyTask(db.Model):
__tablename__ = 'myTask'
id = db.Column(db.Integer, primary_key=True)
taskTitle = db.Column(db.String())
instruction = db.Column(db.String())
dueDate = db.Column(db.String())
volume = db.Column(db.Integer)
number = db.Column(db.Integer)
assignedTo = db.Column(db.Integer)
assigneeID = db.Column(db.Integer)
status = db.Column(db.Integer)
def __init__(self, taskTitle, instruction, dueDate, volume, number,
assignedTo, assigneeID, status):
self.taskTitle = taskTitle
self.instruction = instruction
self.dueDate = dueDate
self.volume = volume
self.number = number
self.assignedTo = assignedTo
self.assigneeID = assigneeID
self.status = status
def __repr__(self):
return '<id {}>'.format(self.id)
def serialize(self):
return {
'id': self.id,
'taskTitle': self.taskTitle,
'instruction': self.instruction,
'dueDate': self.dueDate,
'volume': self.volume,
'number': self.number,
'assignedTo': self.assignedTo,
'assigneeID': self.assigneeID,
'status': self.status
}
class SocialMediaSchedule(db.Model):
__tablename__ = 'SocialMediaSchedule'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String())
time = db.Column(db.String())
date = db.Column(db.String())
permalink = db.Column(db.String())
excerpt = db.Column(db.String())
status = db.Column(db.Integer)
review = db.Column(db.Integer)
author = db.Column(db.Integer)
def __init__(self, title, time, date, permalink, excerpt, status, review,
author):
self.title = title
self.time = time
self.date = date
self.permalink = permalink
self.excerpt = excerpt
self.status = status
self.review = review
self.author = author
def __repr__(self):
return '<id {}>'.format(self.id)
def serialize(self):
return {
'id': self.id,
'title': self.title,
'time': self.time,
'date': self.date,
'permalink': self.permalink,
'excerpt': self.excerpt,
'status': self.status,
'review': self.review,
'author': self.author
}
class Quiz(db.Model):
__tablename__ = 'quizzes'
id = db.Column(db.Integer, primary_key=True)
course_id = db.Column(db.Integer, db.ForeignKey('courses.id'))
name = db.Column(db.String(), nullable=False)
start_time = db.Column(db.DateTime, nullable=False, default=datetime.now)
end_time = db.Column(db.DateTime, nullable=False, default=datetime.now)
questions = db.relationship('Question', backref='quiz')
responses = db.relationship('QuizResponse', backref='quiz')
@property
def marks(self):
ans = 0
for q in self.questions:
ans += q.marks
return ans
class Appointment(db.Model):
__tablename__ = 'appointents'
id = db.Column(db.Integer, primary_key=True)
patient_id = db.Column(db.Integer,
db.ForeignKey('patients.id'),
nullable=False)
doctor_id = db.Column(db.Integer,
db.ForeignKey('users.id'),
nullable=False)
date = db.Column(db.DateTime, nullable=False)
created_on = db.Column(db.DateTime, nullable=False, default=datetime.now)
status = db.Column(db.String(10), default='pending')
doctor = db.relationship('User',
backref='appointments',
lazy=True,
cascade='delete')
patient = db.relationship('Patient',
backref='appointments',
lazy=True,
cascade='delete')
