class Solved_Classroom_Assignment(db.Model):
__tablename__ = 'solved_classroom_assignments'
classroom_id = db.Column(db.Integer, db.ForeignKey('classroom.id'))
student_id = db.Column(db.Integer, db.ForeignKey('students.id'))
assignment_id = db.Column(db.Integer, db.ForeignKey('assignments.id'))
points = db.Column(db.Integer)
classroom = db.relationship(
'Classroom',
backref=backref("Solved_Classroom_Assignment_JOIN_Classroom",
cascade="all,delete"))
student = db.relationship(
'Student', backref="Solved_Classroom_Assignment_JOIN_Student")
assignment = db.relationship(
'Assignments',
backref=backref("Solved_Classroom_Assignment_JOIN_Assignments",
cascade="all,delete"))
__table_args__ = (db.PrimaryKeyConstraint(
classroom_id,
student_id,
assignment_id,
), )
def __init__(self, classroom_id, assignment_id, student_id, points):
self.classroom_id = classroom_id
self.student_id = student_id
self.assignment_id = assignment_id
self.points = points
class PatientTest(db.Model):
__tablename__ = 'patient_test'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80), nullable=False)
details = db.Column(db.String(150))
patient_id = db.Column(db.Integer,
db.ForeignKey('patient.id'),
nullable=False)
appointment_id = db.Column(db.Integer,
db.ForeignKey('appointment.id'),
nullable=False)
patient = db.relationship('Patient',
backref=db.backref('test',
lazy='dynamic',
cascade="all, delete"))
appointment = db.relationship('Appointment',
backref=db.backref('patient_test',
lazy='dynamic',
cascade="all, delete"))
def __init__(self, name, details, patient_id, appointment_id):
self.name = name
self.details = details
self.patient_id = patient_id
self.appointment_id = appointment_id
def __repr__(self):
return f'patient_test({self.id},{self.name},{self.patient_id},{self.details},{self.appointment_id})'
def save(self):
db.session.add(self)
db.session.commit()
class AppointmentRequest(db.Model):
__tablename__ = 'appointment_request'
id = db.Column(db.Integer, primary_key=True)
date = db.Column(db.Date, nullable=False, index=True)
visit_reason = db.Column(db.String(60), nullable=False)
status = db.Column(db.SmallInteger, default=0)
patient_id = db.Column(db.Integer,
db.ForeignKey('patient.id'),
nullable=False)
doctor_id = db.Column(db.Integer,
db.ForeignKey('doctor.id'),
nullable=False)
patient = db.relationship('Patient',
backref=db.backref('appointment_request',
lazy='dynamic'))
doctor = db.relationship('Doctor',
backref=db.backref('appointment_request',
lazy='dynamic'))
def __init__(self, date, visit_reason, patient_id, doctor_id):
self.date = date
self.visit_reason = visit_reason
self.patient_id = patient_id
self.doctor_id = doctor_id
def __repr__(self):
return f'appointment({self.id},{self.date},{self.visit_reason},{self.status},{self.patient_id},{self.doctor_id})'
def save(self):
db.session.add(self)
db.session.commit()
class Aircraft(db.Model):
__tablename__ = 'aircraft'
call_sign=db.Column(db.String, primary_key=True)
model_no=db.Column(db.String)
turn_around_count=db.Column(db.Integer)
sc= db.Column(db.String)
ds= db.Column(db.String)
emergency=db.Column(db.Boolean)
altitude=db.Column(db.Integer)
pilot=db.Column(db.Integer,db.ForeignKey('pilots.id'))
distance=db.Column(db.Integer)
crash=db.Column(db.Boolean)
company=db.Column(db.Text, db.ForeignKey('company.id'))
speed=db.Column(db.Integer)
delay=db.Column(db.Integer)
def __init__(self,call_sign,model_no,turn_around_count,sc,ds,emergency,altitude,pilot,distance,crash,company,speed,delay):
self.call_sign=call_sign
self.model_no=model_no
self.turn_around_count=turn_around_count
self.sc=sc
self.ds=ds
self.emergency=emergency
self.altitude=altitude
self.pilot=pilot
self.distance=distance
self.crash=crash
self.company=company
self.speed=speed
self.delay=delay
def __repr__(self):
return f"{self.call_sign} {self.model_no} {self.turn_around_count} {self.sc} {self.ds} {self.emergency} {self.altitude} {self.pilot} {self.distance} {self.crash} {self.company} {self.speed} {self.delay} "
class Assignments(db.Model):
__tablename__ = 'assignments'
id = db.Column(db.Integer, primary_key=True)
assignment_name = db.Column(db.Text)
course_id = db.Column(db.Integer,
db.ForeignKey('courses.id')) # Assignment tag
course = db.relationship('Courses',
backref='Courses_JOIN_Assignments') # Backref
difficulty = db.Column(db.Text)
assignment_rating = db.Column(db.Float)
assignment_no_of_reviews = db.Column(db.Integer)
assignment_no_of_ratings = db.Column(db.Integer)
active_status = db.Column(db.Integer)
teacher_id = db.Column(db.Integer, db.ForeignKey('teachers.id'))
teacher = db.relationship('Teacher',
backref=backref("Teacher_JOIN_Assignments",
cascade="all,delete")) # Backref
def __init__(self, assignment_name, course_id, difficulty,
assignment_rating, assignment_no_of_reviews,
assignment_no_of_ratings, active_status, teacher_id):
self.assignment_name = assignment_name
self.course_id = course_id
self.difficulty = difficulty
self.assignment_rating = assignment_rating
self.assignment_no_of_reviews = assignment_no_of_reviews
self.assignment_no_of_ratings = assignment_no_of_ratings
self.active_status = active_status
self.teacher_id = teacher_id
class Students(db.Model):
__tablename__ = 'student'
usn = db.Column(db.String(40), primary_key=True, unique=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
first_name = db.Column(db.String(140))
last_name = db.Column(db.String(140))
address = db.Column(db.String(240))
branch = db.Column(db.String(140),
db.ForeignKey('branch.branch_id'),
nullable=False)
sem = db.Column(db.String(140))
sec = db.Column(db.String(140))
attend = db.relationship('Attendances',
backref='attendances',
foreign_keys='Attendances.usn')
s_users = db.relationship('User', backref='students', uselist=False)
def __init__(self, usn, first_name, last_name, branch, sem, sec, address,
user_id):
self.usn = usn
self.first_name = first_name
self.last_name = last_name
self.address = address
self.branch = branch
self.sem = sem
self.sec = sec
self.user_id = user_id
class UserRoles(db.Model):
__tablename__ = 'user_roles'
id = db.Column(db.Integer(), primary_key=True)
user_id = db.Column(db.Integer(),
db.ForeignKey('users.id', ondelete='CASCADE'))
role_id = db.Column(db.Integer(),
db.ForeignKey('roles.id', ondelete='CASCADE'))
def __init__(self, user_id, role_id):
self.user_id = user_id
self.role_id = role_id
class Detail(db.Model):
__tablename__ = "detail"
id = db.Column(db.Integer,
autoincrement=True,
primary_key=True,
nullable=False) # 主键自增，唯一，不可为空
dish_id = db.Column(db.Integer, db.ForeignKey("menu.id"), nullable=False)
order_id = db.Column(db.Integer, db.ForeignKey("order.id"), nullable=False)
quantity = db.Column(db.Integer, nullable=False)
def __repr__(self):
return "Detail object: name=%s" % self.name
class StudentsInMeeting(db.Model):
id = db.Column(db.Integer,primary_key= True)
IDM = db.Column(db.Integer,db.ForeignKey('meetings.IDM'))
EmailS = db.Column(db.String(64),db.ForeignKey('students.emails'))
Attendance = db.Column(db.Text)
def __init__(self,IDM,EmailS,Attendance):
self.IDM = IDM
self.EmailS = EmailS
self.Attendance = Attendance
def __repr__(self):
return f"Student Email: {self.EmailS}, ID of Meeting: {self.IDM}. "
class Table(db.Model):
__tablename__ = "table"
id = db.Column(db.Integer,
autoincrement=True,
primary_key=True,
nullable=False) # 主键自增，唯一，不可为空
order_id = db.Column(db.Integer, db.ForeignKey("order.id"), nullable=True)
staff_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=True)
status = db.Column(db.String(64), nullable=False)
def __repr__(self):
return "Table object: id=%s" % self.id
'''
class UsedSupply(db.Model):
__tablename__ = "used_supply"
id = db.Column(db.Integer,primary_key = True)
supply_id = db.Column(db.Integer,db.ForeignKey('supply.id'))
event_id = db.Column(db.Integer,db.ForeignKey('event.id'))
quantity = db.Column(db.Text)
def __init__(self, supply_id, event_id, quantity):
self.supply_id = supply_id
self.event_id = event_id
self.quantity = quantity
def __repr__(self):
return f'supply_id: {self.supply_id} event_id: {self.event_id} quantity: {self.quantity}'
class Patient(db.Model):
__tablename__ = 'patient'
id = db.Column(db.Integer, primary_key=True, index=True)
name = db.Column(db.String(70), nullable=False)
gender = db.Column(db.String(8), nullable=False)
address = db.Column(db.String(150), nullable=False)
city = db.Column(db.String(150))
dob = db.Column(db.DateTime)
contact = db.Column(db.BigInteger, unique=True)
user_id = db.Column(db.BigInteger,
db.ForeignKey('user.id'),
nullable=False)
user = db.relationship('User',
backref=db.backref('patient',
lazy='dynamic',
cascade="delete"))
def __init__(self, name, gender, address, city, dob, contact, user_id):
self.name = name
self.gender = gender
self.address = address
self.city = city
self.dob = dob
self.contact = contact
self.user_id = user_id
def __repr__(self):
return f'patient({self.id},{self.name},{self.gender},{self.address},{self.city},{self.dob},{self.contact})'
def save(self):
db.session.add(self)
db.session.commit()
class Event(db.Model):
id = db.Column(db.Integer, primary_key=True)
# Creating the foreign key (<tablename>.<attributename>)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
event_creation_time = db.Column(db.DateTime,
nullable=False,
default=datetime.now(
pytz.timezone('Asia/Calcutta')))
scheduler_time = db.Column(db.DateTime, nullable=False)
title = db.Column(db.String(512), nullable=False)
five_min_reminded = db.Column(db.Boolean, default=False)
one_hour_reminded = db.Column(db.Boolean, default=False)
def __init__(self, title, scheduler_time, user_id):
self.title = title
self.scheduler_time = scheduler_time
self.user_id = user_id
def __repr__(self):
return f'Event Title: {self.title}, 5_min_rem={self.five_min_reminded}'
# For sorting
def __lt__(self, other):
return self.scheduler_time < other.scheduler_time
class Settings(db.Model):
__tablename__ = 'settings'
student_id = db.Column(
db.Integer, db.ForeignKey('students.id'),
primary_key=True) # Can be a PK because its a 1-1 Relationship
display_rank = db.Column(db.Boolean)
display_stats = db.Column(db.Boolean)
student = db.relationship('Student',
backref="Student_JOIN_Settings",
uselist=False) # Backref
def __init__(self, student_id, display_rank, display_stats):
self.student_id = student_id
self.display_rank = display_rank
self.display_stats = display_stats
# Function that returns settings code
def return_setting_preset(self):
if self.display_rank and self.display_stats:
return 1 # Display both == 1
elif self.display_rank and not self.display_stats:
return 2 # Display rank only == 2
elif self.display_stats and not self.display_rank:
return 3 # Display stats only == 3
else:
return 4 # Hide both == 4
class Schedule(db.Model):
__tablename__ = 'schedule'
id = db.Column(db.Integer, primary_key=True, index=True)
day = db.Column(db.String(10), nullable=False)
start_time = db.Column(db.Time)
end_time = db.Column(db.Time)
doctor_id = db.Column(db.Integer,
db.ForeignKey('doctor.id'),
nullable=False)
doctor = db.relationship('Doctor',
backref=db.backref('schedule',
lazy='dynamic',
cascade="all, delete"))
def __init__(self, day, start_time, end_time, doctor_id):
self.day = day
self.start_time = start_time
self.end_time = end_time
self.doctor_id = doctor_id
def __repr__(self):
return f'schedule({self.id},{self.day},{self.start_time},{self.end_time})'
def save(self):
db.session.add(self)
db.session.commit()
class BlogPost(db.Model):
# Setup the relationship to the User table
users = db.relationship(User)
# Model for the Blog Posts on Website
id = db.Column(db.Integer, primary_key=True)
# Notice how we connect the BlogPost to a particular author
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
date = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
blog_img = db.Column(db.String(20), default='default_img.png')
title = db.Column(db.String(140), nullable=False)
topic = db.Column(db.String(60), nullable=False)
text = db.Column(db.Text, nullable=False)
blogcount = db.relationship('Blogcount', backref='coupos')
usr = db.relationship('User', backref='userspost')
def __init__(self, title, text, topic, blog_img, user_id):
self.title = title
self.text = text
self.topic = topic
self.blog_img = blog_img
self.user_id = user_id
def __repr__(self):
return f"Post Id: {self.id} --- Date: {self.date} --- Title: {self.title}"
class Condidate(db.Model):
__tablename__ = 'condidates'
id = db.Column(db.Integer,primary_key= True)
group_id = db.Column(db.Integer,db.ForeignKey('groups.id'))
emailc = db.Column(db.String(64), unique=True, index=True)
pronounc = db.Column(db.Text)
phonenumc = db.Column(db.String(10))
stimes = db.Column(db.Text)
text = db.Column(db.Text)
status = db.Column(db.Text)
firstname = db.Column(db.Text)
lastname = db.Column(db.Text)
def __init__(self,group_id,emailc,pronounc,phonenumc,stimes,text,status,firstname,lastname):
self.group_id = group_id
self.emailc = emailc
self.pronounc = pronounc
self.phonenumc = phonenumc
self.stimes = stimes
self.text = text
self.status = status
self.firstname =firstname
self.lastname = lastname
class Assignment_Data(db.Model):
__tablename__ = 'assignment_data'
assignment_id = db.Column(db.Integer, db.ForeignKey('assignments.id'))
question_id = db.Column(db.Integer)
question_text = db.Column(db.Text)
assignment = db.relationship('Assignments',
backref=backref(
"Assignment_Data_JOIN_Assignments",
cascade="all,delete")) # Backref
choice1 = db.Column(db.Text)
choice2 = db.Column(db.Text)
choice3 = db.Column(db.Text)
choice4 = db.Column(db.Text)
answer = db.Column(db.Text)
__table_args__ = (db.PrimaryKeyConstraint(
assignment_id,
question_id,
), )
def __init__(self, assignment_id, question_id, question_text, choice1,
choice2, choice3, choice4, answer):
self.assignment_id = assignment_id
self.question_id = question_id
self.question_text = question_text
self.choice1 = choice1
self.choice2 = choice2
self.choice3 = choice3
self.choice4 = choice4
self.answer = answer
class User(db.Model, UserMixin):
# Create a table in the db
__tablename__ = 'users'
id = db.Column(db.Integer,db.ForeignKey('volunteers.IDV'), primary_key = True)
email = db.Column(db.String(64), unique=True, index=True)
username = db.Column(db.String(64), unique=True, nullable=False, index=True)
firstname = db.Column(db.Text)
lastname = db.Column(db.Text)
tel = db.Column(db.Text)
permission = db.Column(db.Text)
password_hash = db.Column(db.String(128))
def __init__(self,id, email, username,firstname, lastname,tel,permission,password):
self.id = id
self.email = email
self.username = username
self.firstname = firstname
self.lastname = lastname
self.tel = tel
self.permission = permission
self.password_hash = generate_password_hash(password)
def check_password(self,password):
# https://stackoverflow.com/questions/23432478/flask-generate-password-hash-not-constant-output
return check_password_hash(self.password_hash,password)
class TestReport(db.Model):
__tablename__ = 'test_report'
id = db.Column(db.Integer, primary_key=True)
filename = db.Column(db.String(64), nullable=False)
test_id = db.Column(db.Integer,
db.ForeignKey('patient_test.id'),
nullable=False,
unique=True)
test = db.relationship('PatientTest',
backref=db.backref('report',
uselist=False,
cascade="delete"))
def __init__(self, filename, test_id):
self.filename = filename
self.test_id = test_id
def __repr__(self):
return f'test_report({self.id},{self.filename},{self.test_id})'
def save(self):
db.session.add(self)
db.session.commit()
class Meetings(db.Model):
IDM = db.Column(db.Integer,primary_key= True)
Mdate = db.Column(db.Text)
Mtime = db.Column(db.Text)
IDG = db.Column(db.Integer,db.ForeignKey('groups.id'))
Occurence = db.Column(db.Text)
Platform = db.Column(db.Text)
title = db.Column(db.Text)
Rate = db.Column(db.Integer)
Pros = db.Column(db.String(500))
Cons = db.Column(db.String(500))
attending = db.Column(db.String(500))
DateAdded = db.Column(db.Text)
studentsinMeeting = db.relationship('StudentsInMeeting',backref='meetings',lazy='dynamic')
def __init__(self,Mdate,Mtime,IDG,Occurence,Platform,title,Rate,Pros,Cons,attending,DateAdded):
self.Mdate = Mdate
self.Mtime = Mtime
self.IDG = IDG
self.Occurence= Occurence
self.Platform = Platform
self.title = title
self.Rate = Rate
self.Pros = Pros
self.Cons = Cons
self.attending = attending
self.DateAdded = DateAdded
class Actor(db.Model):
"""This class represents a table actors in the database
"""
__tablename__ = 'actors'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), unique=True, index=True)
added_on = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
short_bio = db.Column(db.Text, nullable=False)
picture = db.Column(db.String())
# Connecting the Actor to a particular user (adder)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
# Setup the relationship to the User table
users = db.relationship(User)
# This connects Movie to an Actor Author.
movies = db.relationship('Movie', backref='author', lazy=True)
def __repr__(self):
"""This method helps to easily print an instance of the class"""
return f"<Actor ID: {self.id} --{self.name}--Added_on:{self.added_on}>"
@property
def serialize(self):
"""This method will help to represent the class User as a json object
"""
return {
'id': self.id,
'name': self.name,
'added_on': self.added_on,
'short_bio': self.short_bio,
'picture': self.picture,
'user_id': self.user_id,
'movies': [m.serialize for m in self.movies]
}
class BlogPost(db.Model):
"""This class represents a table movies in the database
"""
__tablename__ = 'blogPosts'
id = db.Column(db.Integer, primary_key=True)
posted_on = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
title = db.Column(db.String(140), nullable=False)
text = db.Column(db.Text, nullable=False)
# Connecting the BlogPost to a particular user (poster)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
# Setup the relationship to the User table
users = db.relationship(User)
@property
def serialize(self):
"""This method will help to represent the class User as a json object
"""
return {
'id': self.id,
'posted_on': self.posted_on,
'title': self.title,
'text': self.text,
'user_id': self.user_id
}
def __repr__(self):
"""This method helps to easily print an instance of the class"""
return f"<Post ID: {self.id} -- Date: {self.date} --- {self.title}>"
class Product(db.Model):
__tablename__ = "products"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String)
manufacturer = db.Column(db.String)
quantity = db.Column(db.Float)
sku = db.Column(db.Float)
min_Bid = db.Column(db.Float)
image = db.Column(db.String)
description = db.Column(db.String)
sold_quantity = db.Column(db.Float)
rating = db.Column(db.Float)
comments = db.Column(db.String)
category_id = db.Column(db.Integer, db.ForeignKey("categories.id"))
#admins = db.relationship('Admin',backref='admins')
consultant = db.Column(db.String)
tags = db.Column(db.String)
shipping_price = db.Column(db.Float)
location = db.Column(db.String)
price = db.Column(db.Float)
expire_data = db.Column(db.String)
# file = db.relationship('File', backref='users')
def __init__(self, name, manufacturer, quantity, cost):
self.name = name
self.manufacturer = manufacturer
self.quantity = quantity
self.cost = cost
class Comment(db.Model):
id = db.Column(db.Integer, primary_key=True)
body = db.Column(db.String(100), nullable=False)
timestamp = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
post_id = db.Column(db.Integer, db.ForeignKey('post.id'), nullable=False)
def __repr__(self):
return f"Comment('{self.body}', '{self.timestamp}')"
class Answers(db.Model):
id = db.Column(db.Integer, primary_key=True)
question_id = db.Column(db.Integer, db.ForeignKey(Questions.id))
body = db.Column(db.Text)
def __init__(self, body, question_id):
self.body = body
self.question_id = question_id
class Category(db.Model):
__tablename__ = "categories"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String, unique=True)
product_id = db.Column(db.Integer, db.ForeignKey("products.id"))
def __init__(self, name):
self.name = name
class VolunteersInGroups(db.Model):
id = db.Column(db.Integer,primary_key=True)
#IDV = db.relationship('Volunteers',backref='VolunteersInGroups',uselist=False)
IDV = db.Column(db.Integer,db.ForeignKey('volunteers.IDV'))
#IDG = db.relationship('Group',backref='VolunteersInGroups',uselist=False)
IDG = db.Column(db.Integer,db.ForeignKey('groups.id'))
TimeS = db.Column(db.Text)
TimeF = db.Column(db.Text)
statusV = db.Column(db.Text)
def __init__(self,IDV,IDG,TimeS,TimeF,statusV):
self.IDV = IDV
self.IDG = IDG
self.TimeS = TimeS
self.TimeF = TimeF
self.statusV = statusV
class Owner(db.Model):
__tablename__ = 'owner'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Text)
puppy_id = db.Column(db.Integer, db.ForeignKey('puppies.id'))
def __init__(self, name, puppy_id):
self.name = name
self.puppy_id = puppy_id
class Post(db.Model):
id = db.Column(db.Integer, primary_key= True)
title = db.Column(db.String(100), nullable=False)
date_posted = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
content = db.Column(db.Text, nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
def __repr__(self):
return f"Post('{self.title}','{self.date_posted}')"
