class Courses(db.Model):
id = db.Column(db.Integer, primary_key=True)
number = db.Column(db.Integer)
major = db.Column(db.String(12))
course_name = db.Column(db.String(100))
components = db.relationship("Components", backref="course")
course_sections = db.relationship("Sections", backref="course")
final_schedules = db.relationship("ScheduleFinal",
backref=db.backref("course",
lazy="joined"))
student_planning_data = db.relationship("StudentPlanningData",
backref=db.backref("course",
lazy="joined"))
course_preferences = db.relationship("FacultyCoursePreferences",
backref=db.backref("course",
lazy="joined"))
@property
def serialize(self):
#"""Return object data in easily serializeable format"""
return {
'id': self.id,
'number': self.number,
'major': self.major,
'course_name': self.course_name
#'components': self.components
#'course_sections': self.course_sections,
#'final_schedules': self.final_schedules,
}
class Artist(db.Model):
__tablename__ = 'artists'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50), nullable=False)
songs = db.relationship('Song', backref='artist', lazy=True)
albums = db.relationship('Album', backref='artist', lazy=True)
def __repr__(self):
return f"Artist('{self.name}', '{self.albums}','{self.songs}')"
class Users(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(25), unique=True, nullable=False)
password = db.Column(db.String(60), nullable=False)
date_reg = db.Column(db.DateTime, default=datetime.utcnow, nullable=False)
mail = db.Column(db.String(120), unique=True, nullable=False)
image_file = db.Column(db.String(20), nullable=False, default='default.png')
post = db.relationship('Post', backref='author', lazy=True)
todo = db.relationship('Todo', backref='mail', lazy=True)
def __repr__(self):
return f"Users('{self.username}', '{self.mail}')"
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
image_file = db.Column(db.String(20),
nullable=False,
default='default.jpg')
password = db.Column(db.String(60), nullable=False)
posts = db.relationship('Post', backref='author', lazy=True)
def get_reset_token(self, expires_sec=1800):
s = Serializer(app.config['SECRET_KEY'], expires_sec)
return s.dumps({'user_id': self.id}).decode('utf-8')
@staticmethod
def verify_reset_token(token):
s = Serializer(app.config['SECRET_KEY'])
try:
user_id = s.loads(token)['user_id']
except:
return None
return User.query.get(user_id)
def __repr__(self):
return f"User('{self.username}', '{self.email}', '{self.image_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 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 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 User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(255), unique=True)
password = db.Column(db.String(255))
active = db.Column(db.Boolean())
confirmed_at = db.Column(db.DateTime())
roles = db.relationship('Role',
secondary=roles_users_association_table,
backref=db.backref('users', 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 Role(db.Model):
__tablename__ = 'roles'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), unique=True)
default = db.Column(db.Boolean, default=False, index=True)
permissions = db.Column(db.Integer)
users = db.relationship('User', backref='role', lazy='dynamic')
def __init__(self, **kwargs):
super(Role, self).__init__(**kwargs)
if self.permissions is None:
self.permissions = 0
@staticmethod
def insert_roles():
roles = {
'User': [Permission.FOLLOW, Permission.COMMENT, Permission.WRITE],
'Moderator': [
Permission.FOLLOW, Permission.COMMENT, Permission.WRITE,
Permission.MODERATE
],
'Administrator': [
Permission.FOLLOW, Permission.COMMENT, Permission.WRITE,
Permission.MODERATE, Permission.ADMIN
],
}
default_role = 'User'
for r in roles:
role = Role.query.filter_by(name=r).first()
if role is None:
role = Role(name=r)
role.reset_permissions()
for perm in roles[r]:
role.add_permission(perm)
role.default = (role.name == default_role)
db.session.add(role)
db.session.commit()
def add_permission(self, perm):
if not self.has_permission(perm):
self.permissions += perm
def remove_permission(self, perm):
if self.has_permission(perm):
self.permissions -= perm
def reset_permissions(self):
self.permissions = 0
def has_permission(self, perm):
return self.permissions & perm == perm
def __repr__(self):
return '<Role %r>' % self.name
class User(UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), index=True, unique=True)
email = db.Column(db.String(120), index=True, unique=True)
password_hash = db.Column(db.String(128))
posts = db.relationship('Post', backref='author')
def set_password(self, password):
self.password_hash = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password_hash, password)
class Byke_user(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), unique=True, nullable=False)
email = db.Column(db.String(80), unique=True, nullable=False)
user_image = db.Column(db.String(20), nullable=False, default='default.png')
password = db.Column(db.String(60), nullable=False)
upload = db.Column(db.String(20), nullable=True)
trips = db.relationship('Byke_trip', backref='author', lazy=True)
stats = db.relationship('Byke_trip_stats', backref='author', lazy=True)
# -----------------------------------------------------
# Function: __repr__
# Author:
# Modified: Tanner L
# Date: 10/01/19
# Desc: specifies what to return for class query
# Inputs:
# Outputs: returns username, email, user image
# -----------------------------------------------------
def __repr__(self):
return f"Byke_user('{self.username}', '{self.email}', '{self.user_image}')"
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 Movie(db.Model):
__tablename__ = 'movies'
id = db.Column(db.Integer, primary_key=True)
budget = db.Column(db.String(255))
genres = db.relationship('Genre',
secondary=movies_genres,
lazy='dynamic',
backref=db.backref('movies', lazy='dynamic'))
rated_users = db.relationship('User',
secondary='user_rated_movies',
lazy='dynamic',
backref=db.backref('rated_movies'))
homepage = db.Column(db.String(255))
keywords = db.Column(db.Text)
original_language = db.Column(db.String(255))
original_title = db.Column(db.String(255))
overview = db.Column(db.Text)
popularity = db.Column(db.Float)
production_companies = db.relationship('Company',
secondary=movies_companies,
lazy='dynamic',
backref=db.backref('movies',
lazy='dynamic'))
production_countries = db.relationship('Country',
secondary=movies_countries,
lazy='dynamic',
backref=db.backref('movies',
lazy='dynamic'))
release_date = db.Column(db.DateTime)
revenue = db.Column(db.BigInteger)
runtime = db.Column(db.Integer)
spoken_languages = db.Column(db.Text)
status = db.Column(db.String(255))
tagline = db.Column(db.String(255))
title = db.Column(db.String(255))
vote_average = db.Column(db.Float)
vote_count = db.Column(db.BigInteger)
poster_link = db.Column(db.String(255))
imdb_id = db.Column(db.String(255))
class Faculty(db.Model):
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(32))
last_name = db.Column(db.String(32))
max_work_units = db.Column(db.Integer)
min_work_units = db.Column(db.Integer)
current_work_units = db.Column(db.Integer)
faculty_sections = db.relationship("Sections", backref="faculty")
preferences = db.relationship("FacultyPreferences", backref="faculty")
course_preferences = db.relationship("FacultyCoursePreferences",
backref="faculty")
@property
def serialize(self):
#"""Return object data in easily serializeable format"""
return {
'id': self.id,
'first_name': self.first_name,
'last_name': self.last_name,
'min_work_units': self.min_work_units,
'max_work_units': self.max_work_units,
'current_work_units': self.current_work_units
}
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 User(db.Model):
# add columns
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), unique=True, nullable=True)
email = db.Column(db.String(120), unique=True, nullable=True)
image_file = db.Column(db.String(20),
nullable=False,
default='default.jpg'
) # we hash the image files to strings #profile pic
password = db.Column(db.String(60),
nullable=False) # hashing passwords to 60 char length
posts = db.relationship('Post', backref='author', lazy=True)
def __repr__(self):
return f"User('{self.username}', '{self.email}', '{self.image_file}')"
class Experiments(db.Model):
id = db.Column(db.Integer, primary_key=True, nullable=False,
unique=True, autoincrement=True)
experiment_name = db.Column(db.String(30), nullable=False, unique=True)
description = db.Column(db.String(300), default="")
data = db.relationship('ExperimentData', backref='experiment_id')
@classmethod
def get_headers(self):
header = ('Experiment Id', 'Experiment Name', 'Data Colected')
return header
@classmethod
def get_data(self, id):
exp = Experiments.query.filter_by(id=id).first()
return exp
def __repr__(self):
return f"id:\n{self.id}\n experiment_name: {self.experiment_name}"
class Rooms(db.Model):
id = db.Column(db.Integer, primary_key=True)
number = db.Column(db.String(32))
type = db.Column(db.String(32))
capacity = db.Column(db.Integer)
equipment = db.Column(db.String(128))
comments = db.Column(db.String(128))
room_sections = db.relationship("Sections", backref="room")
@property
def serialize(self):
#"""Return object data in easily serializeable format"""
return {
'id': self.id,
'number': self.number,
'capacity': self.capacity,
'type': self.type,
'equipment': self.equipment,
'comments': self.comments
}
class Terms(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64))
published = db.Column(db.Boolean)
term_sections = db.relationship("Sections", backref="term")
comments = db.relationship("Comments", backref="term")
final_schedules = db.relationship("ScheduleFinal", backref="term")
preferences = db.relationship("FacultyPreferences", backref="term")
course_preferences = db.relationship("FacultyCoursePreferences",
backref="term")
student_planning_data = db.relationship("StudentPlanningData",
backref="term")
# schedules = db.relationship("Schedule", backref="term")
@property
def serialize(self):
# set quarterId and year for sorting purposes. quarterId: spring = 0, summer = 1, fall = 2, winter = 3
term = self.name.split()
quarter = term[0]
year = int(term[2])
quarterId = 0
if quarter == "Summer":
quarterId = 1
elif quarter == "Fall":
quarterId = 2
elif quarter == "Winter":
quarterId = 3
#"""Return object data in easily serializeable format"""
return {
'id': self.id,
'name': self.name,
'quarterId': quarterId,
'year': year,
'published': self.published
}
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), index=True, unique=True)
email = db.Column(db.String(120), index=True, unique=True)
password_hash = db.Column(db.String(128))
posts = db.relationship('Post', backref='author')
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
class User(db.Model):
id = db.Column('id', db.Integer, primary_key=True)
username = db.Column('username', db.String(20), unique=True, index=True)
password = db.Column('password', db.String(172))
email = db.Column('email', db.String(50), unique=True, index=True)
registered_on = db.Column('registered_on', db.DateTime)
last_login_date = db.Column('last_login_date', db.DateTime)
logged_in_bol = db.Column('logged_in_bol', db.Boolean)
admin = db.Column('admin', db.Boolean)
smarthouses = db.relationship('SmartHouse',
backref='admin',
lazy='dynamic')
token = db.Column(db.String(32), index=True, unique=True)
token_expiration = db.Column(db.DateTime)
def __init__(self, username, email, admin):
self.username = username
self.email = email
self.registered_on = datetime.utcnow()
self.last_login_date = datetime.utcnow()
self.logged_in_bol = False
self.admin = admin
def get_token(self, expires_in=3600):
now = datetime.utcnow()
if self.token and self.token_expiration > now + timedelta(seconds=60):
return self.token
self.token = base64.b64encode(os.urandom(24)).decode('utf-8')
self.token_expiration = now + timedelta(seconds=expires_in)
db.session.add(self)
return self.token
def revoke_token(self):
self.token_expiration = datetime.utcnow() - timedelta(seconds=1)
@staticmethod
def check_token(token):
user = User.query.filter_by(token=token).first()
if user is None or user.token_expiration < datetime.utcnow():
return None
return user
def to_dict(self, include_email=False):
data = {
'id': self.id,
'username': self.username,
'email': self.email,
'last_login_date': self.last_login_date,
'admin': self.admin
}
return data
def from_dict(self, data, new_user=False):
for field in ['username', 'email', 'admin']:
if field in data:
setattr(self, field, data[field])
if new_user and 'password' in data:
self.set_password(data['password'])
@property
def is_authenticated(self):
return True
# return true if user is authenticated, provided credentials
@property
def is_active(self):
return True
# return true if user is activte and authenticated
@property
def is_annonymous(self):
return False
# return true if annon, actual user return false
def is_admin(self):
return self.admin
# return true if annon, actual user return false
def change_login_in_status(self, bool):
self.logged_in_bol = bool
if not self.logged_in_bol:
self.last_login_date = datetime.utcnow()
db.session.commit()
return self.logged_in_bol
def get_id(self):
try:
return unicode(self.id) # python 2
except NameError:
return str(self.id) # python 3
def check_password(self, password):
# return check_password_hash(self.password, password)
return bcrypt.check_password_hash(self.password, password)
def set_password(self, password):
self.password = bcrypt.generate_password_hash(password).decode(
"utf-8", "ignore")
# Todo : add possibility to admins to create and delete users on site
def verify_reset_password_token(self):
return User.query.get(self.id)
def __repr__(self):
return '<User %r>' % self.username