class courseNote(db.Model):
__tablename__ = 'coursenotes'
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='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 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 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'))
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):
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
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 QuizResponse(db.Model):
__tablename__ = 'quizresponses'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
quiz_id = db.Column(db.Integer, db.ForeignKey('quizzes.id'))
quizQuestionResponses = db.relationship('quizQuestionResponse',
backref='quiz_response')
@property
def marks(self):
ans = 0
for qqr in self.quizQuestionResponses:
ans += qqr.marks
return ans
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 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 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 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 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 Patient(db.Model):
__tablename__ = 'patients'
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(50), nullable=False)
last_name = db.Column(db.String(50), nullable=False)
gender = db.Column(db.String(50), nullable=False)
date_of_birth = db.Column(db.Date, nullable=False)
barangay = db.Column(db.String(255), nullable=False)
address = db.Column(db.String(255), nullable=False)
contact_no = db.Column(db.String(20))
user = db.relationship('User', backref='user', cascade='all, delete')
medical_records = db.relationship('MedicalRecord',
backref='patient',
cascade='all, delete')
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 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 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 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 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 Resource(db.Model):
__tablename__ = 'Resource'
id = db.Column(db.Integer, primary_key=True)
postID = db.Column(db.String())
postType = db.Column(db.String())
number = db.Column(db.String())
photoCaption = db.Column(db.String())
file = db.Column(db.String())
filePath = db.Column(db.String())
provider = db.Column(db.String())
captionUpdate = db.Column(db.String())
def __init__(self, postID,postType,number,photoCaption, file, filePath, provider, captionUpdate):
self.postID = postID
self.postType = postType
self.number = number
self.photoCaption = photoCaption
self.file = file
self.filePath = filePath
self.provider = provider
self.captionUpdate = captionUpdate
def __repr__(self):
return '<id {}>'.format(self.id)
def serialize(self):
return {
'id': self.id,
'postID': self.postID,
'postType': self.postType,
'number':self.number,
'photoCaption':self.photoCaption,
'file':self.file,
'filePath':self.filePath,
'provider':self.provider,
'captionUpdate':self.captionUpdate
}
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 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 Assignment(db.Model):
__tablename__='assignments'
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='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 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 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')
class quizQuestionResponse(db.Model):
__tablename__ = 'quizquestionresponses'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
question_id = db.Column(db.Integer, db.ForeignKey('questions.id'))
quiz_id = db.Column(db.Integer, db.ForeignKey('quizzes.id'))
response = db.Column(db.String(), nullable=False)
quiz_response_id = db.Column(db.Integer, db.ForeignKey('quizresponses.id'))
@property
def isCorrect(self):
print(self.response, self.question.ans)
return sorted(self.response.split(',')) == sorted(
self.question.ans.split(','))
@property
def marks(self):
if self.isCorrect:
return self.question.marks
else:
if self.question.is_partial:
ans = 0
for resp_id_string in self.response.split(','):
print(resp_id_string, self.question.ans.split(','),
self.response)
if resp_id_string in self.question.ans.split(','):
ans += 1
else:
return 0
return ans * self.question.marks / len(
self.question.ans.split(','))
else:
return 0
@property
def attemptlist(self):
return self.response.split(',')
class User(db.Model):
__tablename__ = "users"
id = db.Column('user_id', db.Integer, primary_key=True)
username = db.Column('username', db.String(20), unique=True, index=True)
password = db.Column('password', db.String(255))
email = db.Column('email', db.String(60), unique=True, index=True)
registered_on = db.Column('registered_on', db.DateTime)
def __init__(self, username, password, email):
self.username = username
self.password = password
self.email = email
self.registered_on = datetime.utcnow()
def is_authenticated(self):
return True
def is_active(self):
return True
def is_anonymous(self):
return False
def get_id(self):
return str(self.id)
def __repr__(self):
return '<User %r>' % (self.username)
# don't judge me...
def unique(self):
e_e = email_e = db.session.query(
User.email).filter_by(email=self.email).scalar() is None
u_e = username_e = db.session.query(
User.username).filter_by(username=self.username).scalar() is None
# none exist
if e_e and u_e:
return 0
# email already exists
elif e_e == False and u_e == True:
return -1
# username already exists
elif e_e == True and u_e == False:
return -2
# both already exists
else:
return -3
def serialize(self):
return {
'id': self.id,
'username': self.username,
'email': self.email,
'registered_on': self.registered_on,
}
from enum import unique
# from cms.core.views import index
from cms import db,login_manager
from werkzeug.security import generate_password_hash,check_password_hash
from flask_login import UserMixin
from datetime import datetime
@login_manager.user_loader
def load_user(user_id):
return Professor.query.get(user_id)
course_helper=db.Table('course_helper',
db.Column('user_id',db.Integer,db.ForeignKey('users.id')),
db.Column('course_id',db.Integer,db.ForeignKey('courses.id'))
)
branch_helper=db.Table('branch_helper',
db.Column('course_id',db.Integer,db.ForeignKey('courses.id')),
db.Column('branch_id',db.Integer,db.ForeignKey('branches.id'))
)
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 User(db.Model,UserMixin):
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 Medicine(db.Model):
__tablename__ = 'medicines'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50), unique=True, nullable=False)
count = db.Column(db.Integer, nullable=False)
last_stocked = db.Column(db.DateTime, nullable=False)
class Findings(db.Model):
__tablename__ = 'findings'
id = db.Column(db.Integer, primary_key=True)
findings = db.Column(db.String(50), nullable=False)
from cms import db
Enrollments = db.Table('enrollment',
db.Column("course_id", db.Integer, db.ForeignKey("course.id"), primary_key=True),
db.Column("student_id", db.Integer, db.ForeignKey("student.id"), primary_key=True)
)
