class PostComment(db.Model):
__tablename__ = 'post_comments'
id = db.Column(db.Integer, primary_key=True)
body = db.Column(db.Text)
body_html = db.Column(db.Text)
timestamp = db.Column(db.DateTime, index=True, default=datetime.utcnow)
disabled = db.Column(db.Boolean)
author_id = db.Column(db.Integer, db.ForeignKey('users.id'))
post_id = db.Column(db.Integer, db.ForeignKey('posts.id'))
@staticmethod
def on_changed_body(target, value, oldvalue, initiator):
allowed_tags = [
'a', 'abbr', 'acronym', 'b', 'code', 'em', 'i', 'strong'
]
target.body_html = bleach.linkify(
bleach.clean(markdown(value, output_format='html'),
tags=allowed_tags,
strip=True))
@staticmethod
def from_json(json_comment):
body = json_comment.get('body')
if body is None or body == '':
raise ValidationError('comment does not have a body')
return PostComment(body=body)
class UserFollow(db.Model):
__tablename__ = 'user_follows'
follower_id = db.Column(db.Integer,
db.ForeignKey('users.id'),
primary_key=True)
followed_id = db.Column(db.Integer,
db.ForeignKey('users.id'),
primary_key=True)
timestamp = db.Column(db.DateTime, default=datetime.utcnow)
class UserRatedMovie(db.Model):
__tablename__ = 'user_rated_movies'
movie_id = db.Column(db.Integer,
db.ForeignKey('movies.id'),
primary_key=True)
user_id = db.Column(db.Integer,
db.ForeignKey('users.id'),
primary_key=True)
score = db.Column(db.Float, default=5.0)
timestamp = db.Column(db.DateTime, default=datetime.utcnow)
class Song(db.Model):
__tablename__ = 'songs'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(50), nullable=False)
album_id = db.Column(db.Integer,
db.ForeignKey('albums.id'),
nullable=False)
artist_id = db.Column(db.Integer,
db.ForeignKey('artists.id'),
nullable=False)
file = db.relationship('File', backref='song', lazy=True)
def __repr__(self):
return f"Song('{self.title}','{self.album}', '{self.artist}', '{self.file}')"
class Post(db.Model):
__tablename__ = 'posts'
id = db.Column(db.Integer, primary_key=True)
body = db.Column(db.Text)
body_html = db.Column(db.Text)
timestamp = db.Column(db.DateTime, index=True, default=datetime.utcnow)
author_id = db.Column(db.Integer, db.ForeignKey('users.id'))
comments = db.relationship('PostComment', backref='post', lazy='dynamic')
@staticmethod
def on_changed_body(target, value, oldvalue, initiator):
allowed_tags = [
'a', 'abbr', 'acronym', 'b', 'blockquote', 'code', 'em', 'i', 'li',
'ol', 'pre', 'strong', 'ul', 'h1', 'h2', 'h3', 'p'
]
target.body_html = bleach.linkify(
bleach.clean(markdown(value, output_format='html'),
tags=allowed_tags,
strip=True))
@staticmethod
def from_json(json_post):
body = json_post.get('body')
if body is None or body == '':
raise ValidationError('post does not have a body')
return Post(body=body)
class SmartAction(db.Model):
__tablename__ = "smart_house_action"
id = db.Column('id', db.Integer, primary_key=True)
sensor_id = db.Column(db.Integer, db.ForeignKey('smart_sensor.id'))
time = db.Column('time', db.DateTime)
action = db.Column('action', db.String(50))
outcome = db.Column('outcome', db.String(50))
class CohortData(db.Model):
id = db.Column(db.Integer, primary_key=True)
course_id = db.Column(db.Integer, db.ForeignKey("courses.id"))
major = db.Column(db.String(12))
freshman = db.Column(db.Integer)
sophmores = db.Column(db.Integer)
juniors = db.Column(db.Integer)
seniors = db.Column(db.Integer)
class ScheduleFinal(db.Model):
id = db.Column(db.Integer, primary_key=True)
term_id = db.Column(db.Integer, db.ForeignKey("terms.id"))
course_id = db.Column(db.Integer, db.ForeignKey("courses.id"))
number_sections = db.Column(db.String(4))
total_enrollment = db.Column(db.String(4))
waitlist = db.Column(db.String(4))
@property
def serialize(self):
return {
'id': self.id,
'course_major': self.course.major,
'course_number': self.course.number,
'number_sections': self.number_sections,
'total_enrollment': self.total_enrollment,
'waitlist': self.waitlist
}
class Album(db.Model):
__tablename__ = 'albums'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50), nullable=False)
artist_id = db.Column(db.Integer, db.ForeignKey('artists.id'))
songs = db.relationship('Song', backref='album', lazy=True)
def __repr__(self):
return f"Album('{self.name}','{self.songs}')"
class File(db.Model):
__tablename__ = 'files'
id = db.Column(db.Integer, primary_key=True)
extension = db.Column(db.String(255), nullable=False)
name_on_server = db.Column(db.String(255), nullable=False)
song_id = db.Column(db.Integer, db.ForeignKey('songs.id'))
def __repr__(self):
return f"File('{self.extension}','{self.name_on_server}')"
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100), nullable=False)
content = db.Column(db.Text, nullable=False)
date_posted = db.Column(db.DateTime, nullable=False, default=datetime.now)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
def __repr__(self):
return f"Post('{self.title}', '{self.date_posted}'"
class Todo(db.Model):
id = db.Column(db.Integer, primary_key=True)
comment = db.Column(db.Text, nullable=False)
date_created = db.Column(db.DateTime, nullable=False, default=datetime.now)
priority = db.Column(db.String, nullable=False)
todo_mail = db.Column(db.String, db.ForeignKey('users.mail'))
def __repr__(self):
return f"Todo('{self.comment}', '{self.priority}')"
class FacultyCoursePreferences(db.Model):
id = db.Column(db.Integer, primary_key=True)
faculty_id = db.Column(db.Integer, db.ForeignKey("faculty.id"))
term_id = db.Column(db.Integer, db.ForeignKey("terms.id"))
course_id = db.Column(db.Integer, db.ForeignKey("courses.id"))
preference = db.Column(
db.String(1)) # M - Most wanted, A - able to teach, C - cannot teach
@property
def serialize(self):
return {
'id': self.id,
'faculty_id': self.faculty_id,
'faculty_first_name': self.faculty.first_name,
'faculty_last_name': self.faculty.last_name,
'course_name': self.course.course_name, #course_name
'preference': self.preference
}
class SmartSensor(db.Model):
id = db.Column('id', db.Integer, primary_key=True)
controller_id = db.Column(db.Integer, db.ForeignKey('smart_controller.id'))
sensor = db.Column('sensor', db.Boolean)
gpio = db.Column('gpio', db.Integer)
description = db.Column('description', db.String(50))
registered_on = db.Column('registered_on', db.DateTime)
last_connetion = db.Column('last_connetion', db.DateTime)
actions = db.relationship('SmartAction', backref='sensor', lazy='dynamic')
class SmartController(db.Model):
id = db.Column('id', db.Integer, primary_key=True)
house_id = db.Column(db.Integer, db.ForeignKey('smart_house.id'))
ctype = db.Column('type', db.String(50))
floor = db.Column('floor', db.Integer)
registered_on = db.Column('registered_on', db.DateTime)
last_connetion = db.Column('last_login_date', db.DateTime)
sensors = db.relationship('SmartSensor',
backref='controller',
lazy='dynamic')
class StudentPlanningData(db.Model):
id = db.Column(db.Integer, primary_key=True)
term_id = db.Column(db.Integer, db.ForeignKey("terms.id"))
course_id = db.Column(db.Integer, db.ForeignKey("courses.id"))
number_sections = db.Column(db.Integer)
capacity = db.Column(db.Integer)
seat_demand = db.Column(db.Integer)
unmet_seat_demand = db.Column(db.Integer)
@property
def serialize(self):
return {
'id': self.id,
'course_major': self.course.major,
'course_number': self.course.number,
'number_sections': self.number_sections,
'capacity': self.capacity,
'seat_demand': self.seat_demand,
'unmet_seat_demand': self.unmet_seat_demand
}
class FacultyPreferences(db.Model):
id = db.Column(db.Integer, primary_key=True)
faculty_id = db.Column(db.Integer, db.ForeignKey("faculty.id"))
term_id = db.Column(db.Integer, db.ForeignKey("terms.id"))
day = db.Column(db.String(1)) # 'M', 'T', etc.
time_start = db.Column(db.Time)
time_end = db.Column(db.Time)
preference = db.Column(db.String(15))
@property
def serialize(self):
return {
'id': self.id,
'faculty_id': self.faculty_id,
'day': self.day,
'time_start': self.time_start.isoformat()
[:-3], #[:-3] Removes the seconds from time
'time_end': self.time_end.isoformat()
[:-3], #[:-3] Removes the seconds from time
'choice': self.preference
}
class SmartHouse(db.Model):
id = db.Column('id', db.Integer, primary_key=True)
admin_id = db.Column(db.Integer, db.ForeignKey('user.id'))
location = db.Column('location', db.String(50))
url = db.Column('url', db.String(50))
port = db.Column('port', db.Integer)
floors = db.Column('floors', db.Integer)
registered_on = db.Column('registered_on', db.DateTime)
last_connetion = db.Column('last_connetion', db.DateTime)
controllers = db.relationship('SmartController',
backref='house',
lazy='dynamic')
class ThumbnailImage(db.Model):
__tablename__ = 'thumbnail_image'
id = db.Column(db.Integer, primary_key=True)
path = db.Column(db.String(250), nullable=False)
original_image_id = db.Column(db.Integer, db.ForeignKey('image.id'))
dimensions = db.Column(db.String(25), nullable=True)
original_image = relationship('Image', back_populates='thumbnail_image')
def __init__(self, image_name, original_image):
self.path = image_name
self.original_image = original_image
width, height = PilImage.open(get_full_path(image_name)).size
self.dimensions = '{}x{}'.format(width, height)
class Sections(db.Model):
id = db.Column(db.Integer, primary_key=True)
course_id = db.Column(db.Integer, db.ForeignKey("courses.id"))
term_id = db.Column(db.Integer, db.ForeignKey("terms.id"))
faculty_id = db.Column(db.Integer, db.ForeignKey("faculty.id"))
room_id = db.Column(db.Integer, db.ForeignKey("rooms.id"))
number = db.Column(db.Integer)
section_type = db.Column(db.String(15)) # lecture of lab
time_start = db.Column(db.Integer)
time_end = db.Column(db.Integer)
days = db.Column(db.String(3)) # 'MWF' or "TR"
#schedule_id = db.Column(db.Integer, db.ForeignKey("schedule.id"))
# want course name, faculty name, room number,
@property
def serialize(self):
#"""Return object data in easily serializeable format"""
return {
'id': self.id,
'course': self.course.major,
'course_id': self.course.id,
'course_num':
(Courses.query.filter_by(id=self.course_id).first()).number,
'term_id': self.term_id,
'faculty': self.faculty.last_name, #faculty name
'faculty_id': self.faculty.id,
'room': self.room.number, #room number/id
'room_id': self.room.id,
'number': self.number,
'section_type': self.section_type,
'time_start': timeCalculations.twelveHourTime(self.time_start),
'time_end': timeCalculations.twelveHourTime(self.time_end),
'hours': timeCalculations.hoursBetween(self.time_end,
self.time_start),
'days': self.days,
'capacity': self.room.capacity
}
class Components(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(20))
course_id = db.Column(db.Integer, db.ForeignKey("courses.id"))
workload_units = db.Column(db.String(5))
hours = db.Column(db.String(5))
@property
def serialize(self):
#"""Return object data in easily serializeable format"""
return {
'id': self.id,
'name': self.name,
'course_id': self.course_id,
'workload_units': self.workload_units,
'hours': self.hours
}
class Byke_trip(db.Model):
time = db.Column(db.String(30), nullable=True)
speed = db.Column(db.Float, nullable=True)
lat = db.Column(db.Float, nullable=True)
lng = db.Column(db.Float, nullable=True)
climb = db.Column(db.Float, nullable=True)
trip_id = db.Column(db.Integer, nullable=False)
entry_id = db.Column(db.Integer, primary_key=True, nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('byke_user.id'), nullable=False)
# -----------------------------------------------------
# Function: __repr__
# Author: Tanner L
# Modified:
# Date: 01/10/19
# Desc: specifies what to return for class query
# Inputs:
# Outputs: returns entry_id, trip_id, user_id
# -----------------------------------------------------
def __repr__(self):
return f"Byke_trip_gps('{self.entry_id}', '{self.trip_id}', '{self.user_id}')"
class Comments(db.Model):
id = db.Column(db.Integer, primary_key=True)
term_id = db.Column(db.Integer, db.ForeignKey("terms.id"))
username = db.Column(db.String(32))
comment = db.Column(db.Text)
time = db.Column(db.String(30))
unread = db.Column(db.Boolean, default=True)
type = db.Column(db.String(20))
@property
def serialize(self):
# """Return object data in easily serializeable format"""
return {
'id': self.id,
'term_id': self.term_id,
'username': self.username,
'comment': self.comment,
'time': self.time,
'unread': self.unread,
'type': self.type
}
class Byke_trip_stats(db.Model):
date = db.Column(db.String(20), nullable=True)
time = db.Column(db.Float, nullable=True)
max_speed = db.Column(db.Float, nullable=True)
avg_speed = db.Column(db.Float, nullable=True)
uphill = db.Column(db.Float, nullable=True)
downhill = db.Column(db.Float, nullable=True)
distance = db.Column(db.Float, nullable=True)
trip_id = db.Column(db.Integer, primary_key=True, nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('byke_user.id'), nullable=False)
# -----------------------------------------------------
# Function: __repr__
# Author: Tanner L
# Modified:
# Date: 01/10/19
# Desc: specifies what to return for class query
# Inputs:
# Outputs: returns date, trip_id, user_id
# -----------------------------------------------------
def __repr__(self):
return f"Byke_trip_stats('{self.date}', '{self.trip_id}', '{self.user_id}')"
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
body = db.Column(db.String(140))
timestamp = db.Column(db.DateTime, index=True, default=datetime.utcnow)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
class User(UserMixin, db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(64), unique=True, index=True)
username = db.Column(db.String(64), unique=True, index=True)
role_id = db.Column(db.Integer, db.ForeignKey('roles.id'))
password_hash = db.Column(db.String(128))
confirmed = db.Column(db.Boolean, default=False)
name = db.Column(db.String(64))
location = db.Column(db.String(64))
about_me = db.Column(db.Text())
member_since = db.Column(db.DateTime(), default=datetime.utcnow)
last_seen = db.Column(db.DateTime(), default=datetime.utcnow)
avatar_hash = db.Column(db.String(32))
posts = db.relationship('Post', backref='author', lazy='dynamic')
followed = db.relationship('UserFollow',
foreign_keys=[UserFollow.follower_id],
backref=db.backref('follower', lazy='joined'),
lazy='dynamic',
cascade='all, delete-orphan')
followers = db.relationship('UserFollow',
foreign_keys=[UserFollow.followed_id],
backref=db.backref('followed', lazy='joined'),
lazy='dynamic',
cascade='all, delete-orphan')
comments = db.relationship('PostComment', backref='author', lazy='dynamic')
@staticmethod
def add_self_follows():
for user in User.query.all():
if not user.is_following(user):
user.follow(user)
db.session.add(user)
db.session.commit()
def __init__(self, **kwargs):
super(User, self).__init__(**kwargs)
if self.role is None:
if self.email == current_app.config['SITE_ADMIN']:
self.role = Role.query.filter_by(name='Administrator').first()
if self.role is None:
self.role = Role.query.filter_by(default=True).first()
if self.email is not None and self.avatar_hash is None:
self.avatar_hash = self.gravatar_hash()
self.follow(self)
@property
def password(self):
raise AttributeError('password is not a readable attribute')
@password.setter
def password(self, password):
self.password_hash = generate_password_hash(password)
def verify_password(self, password):
return check_password_hash(self.password_hash, password)
def generate_confirmation_token(self, expiration=3600):
s = Serializer(current_app.config['SECRET_KEY'], expiration)
return s.dumps({'confirm': self.id}).decode('utf-8')
def confirm(self, token):
s = Serializer(current_app.config['SECRET_KEY'])
try:
data = s.loads(token.encode('utf-8'))
except:
return False
if data.get('confirm') != self.id:
return False
self.confirmed = True
db.session.add(self)
return True
def generate_reset_token(self, expiration=3600):
s = Serializer(current_app.config['SECRET_KEY'], expiration)
return s.dumps({'reset': self.id}).decode('utf-8')
@staticmethod
def reset_password(token, new_password):
s = Serializer(current_app.config['SECRET_KEY'])
try:
data = s.loads(token.encode('utf-8'))
except:
return False
user = User.query.get(data.get('reset'))
if user is None:
return False
user.password = new_password
db.session.add(user)
return True
def generate_email_change_token(self, new_email, expiration=3600):
s = Serializer(current_app.config['SECRET_KEY'], expiration)
return s.dumps({
'change_email': self.id,
'new_email': new_email
}).decode('utf-8')
def change_email(self, token):
s = Serializer(current_app.config['SECRET_KEY'])
try:
data = s.loads(token.encode('utf-8'))
except:
return False
if data.get('change_email') != self.id:
return False
new_email = data.get('new_email')
if new_email is None:
return False
if self.query.filter_by(email=new_email).first() is not None:
return False
self.email = new_email
self.avatar_hash = self.gravatar_hash()
db.session.add(self)
return True
def can(self, perm):
return self.role is not None and self.role.has_permission(perm)
def is_administrator(self):
return self.can(Permission.ADMIN)
def ping(self):
self.last_seen = datetime.utcnow()
db.session.add(self)
def gravatar_hash(self):
return hashlib.md5(self.email.lower().encode('utf-8')).hexdigest()
def gravatar(self, size=100, default='identicon', rating='g'):
url = 'https://secure.gravatar.com/avatar'
hash = self.avatar_hash or self.gravatar_hash()
return '{url}/{hash}?s={size}&d={default}&r={rating}'.format(
url=url, hash=hash, size=size, default=default, rating=rating)
def follow(self, user):
if not self.is_following(user):
f = UserFollow(follower=self, followed=user)
db.session.add(f)
def unfollow(self, user):
f = self.followed.filter_by(followed_id=user.id).first()
if f:
db.session.delete(f)
def is_following(self, user):
if user.id is None:
return False
return self.followed.filter_by(followed_id=user.id).first() is not None
def is_followed_by(self, user):
if user.id is None:
return False
return self.followers.filter_by(
follower_id=user.id).first() is not None
@property
def followed_posts(self):
return Post.query.join(UserFollow, UserFollow.followed_id == Post.author_id) \
.filter(UserFollow.follower_id == self.id)
def generate_auth_token(self, expiration):
s = Serializer(current_app.config['SECRET_KEY'], expires_in=expiration)
return s.dumps({'id': self.id}).decode('utf-8')
@staticmethod
def verify_auth_token(token):
s = Serializer(current_app.config['SECRET_KEY'])
try:
data = s.loads(token)
except:
return None
return User.query.get(data['id'])
def __repr__(self):
return '<User %r>' % self.username
title = db.Column(db.String(255))
cast = db.Column(db.Text)
crew = db.Column(db.Text)
class Genre(db.Model):
__tablename__ = 'genres'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255))
movies_genres = db.Table(
'movies_genres',
db.Column('movie_id',
db.Integer,
db.ForeignKey('movies.id'),
primary_key=True),
db.Column('genre_id',
db.Integer,
db.ForeignKey('genres.id'),
primary_key=True))
class Company(db.Model):
__tablename__ = 'companies'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255))
movies_companies = db.Table(
'movies_companies',
class MoviePoster(db.Model):
__tablename__ = 'movie_posters'
movie_id = db.Column(db.Integer,
db.ForeignKey('movies.id'),
primary_key=True)
poster_pic = db.Column(db.Binary)
class ExperimentData(db.Model):
id = db.Column(db.Integer, primary_key=True, nullable=False,
unique=True, autoincrement=True)
data_colected = db.Column(db.Numeric(scale=2), default=0)
experiment_id_relation = db.Column(db.Integer, db.ForeignKey('experiments.id'))
from web_app import db
image_keyword_association_table = db.Table(
'image_keyword_association', db.Model.metadata,
db.Column('image_id', db.Integer, db.ForeignKey('image.id')),
db.Column('keyword_id', db.Integer, db.ForeignKey('keyword.id')))
album_image_association_table = db.Table(
'album_image_association', db.Model.metadata,
db.Column('album_id', db.Integer, db.ForeignKey('album.id')),
db.Column('image_id', db.Integer, db.ForeignKey('image.id')))
portfolio_album_association_table = db.Table(
'portfolio_album_association', db.Model.metadata,
db.Column('album_id', db.Integer, db.ForeignKey('album.id')),
db.Column('portfolio_id', db.Integer, db.ForeignKey('portfolio.id')))
thumbnail_image_association_table = db.Table(
'thumbnail_image_association', db.Model.metadata,
db.Column('thumbnail_id', db.Integer, db.ForeignKey('thumbnail_image.id')),
db.Column('image_id', db.Integer, db.ForeignKey('image.id')))
downsampled_image_association_table = db.Table(
'downsampled_image_association', db.Model.metadata,
db.Column('downsampled_id', db.Integer,
db.ForeignKey('downsampled_image.id')),
db.Column('image_id', db.Integer, db.ForeignKey('image.id')))
roles_users_association_table = db.Table(
'roles_users', db.Column('user_id', db.Integer(),
db.ForeignKey('user.id')),
