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