class Login(UserMixin, db.Model):
__tablename__ = 'login'
l_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
role_id = db.Column(db.Integer())
username = db.Column(db.String(64), unique=True)
password_hash = db.Column(db.String(128))
reg_id = db.Column(db.Integer())
def set_password(self, password):
self.password_hash = pbsha.hash(password)
def check_password(self, password):
return pbsha.verify(password, self.password_hash)
def set_role_id(self, role_id):
self.role_id = role_id
def get_role_id(self):
return self.role_id
def set_reg_id(self, reg_id):
self.reg_id = reg_id
def get_reg_id(self):
return self.reg_id
class Article(db.Model):
url = db.Column(db.String(2048), primary_key=True)
source = db.Column(db.String(100))
author = db.Column(db.String(70))
title = db.Column(db.String(250), nullable=False)
description = db.Column(db.String(1000))
thumbnail_url = db.Column(db.String(2048),
nullable=False,
default="/static/default_thumbnail.jpg")
publish_date = db.Column(db.DateTime)
chars_num = db.Column(db.Integer)
is_fake_news = db.Column(db.Boolean, default=False)
time_added = db.Column(db.DateTime, nullable=False, default=datetime.now())
# referenced by other tables:
articleTags = db.relationship('ArticleTag',
backref='ArticleTag_article',
lazy=True)
articleKeywords = db.relationship('ArticleKeyword',
backref='ArticleKeyword_article',
lazy=True)
articleActions = db.relationship('ArticleAction',
backref='ArticleAction_article',
lazy=True)
def __repr__(self):
return f"Article({self.url})"
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
Username = db.Column(db.String(200), nullable=False, unique=True)
Password = db.Column(db.String(200), nullable=False)
Email = db.Column(db.String(64), nullable=False, unique=True)
Login = db.Column(db.String(64), nullable=False, default="False")
def __repr__(self):
return '<Username {}>'.format(self.Username)
def user_information(self):
return {
"Username": self.Username,
"Password": self.Password, # delete
"Email": self.Email,
"Id": self.id # delete
}
def self_information(self):
return {
"Username": self.Username,
"Password": self.Password,
"Email": self.Email,
"Login": self.Login,
"Id": self.id # delete
}
class Admin(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(32))
password_hash = db.Column(db.String(128))
token = db.Column(db.String(128))
token_expiry = db.Column(db.DateTime)
def set_password(self, password):
self.password_hash = pbkdf.hash(password)
return
def valid_password(self, password):
return pbkdf.verify(password, self.password_hash)
def get_token(self):
self.token = os.urandom(3).hex()
self.token_expiry = datetime.utcnow() + timedelta(seconds=360)
return self.token
def valid_token(self, token):
return token == self.token and self.token_expiry > datetime.utcnow(
) + timedelta(seconds=30)
def invalidate_token(self):
self.token_expiry = datetime.utcnow() - timedelta(seconds=5)
return
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'))
def __repr__(self):
return f'<Post {self.body}>'
class ArticleKeyword(db.Model):
# references Article:
article_url = db.Column(db.String(2048),
db.ForeignKey('article.url'),
primary_key=True)
keyword = db.Column(db.String(200), primary_key=True)
def __repr__(self):
return f"ArticleKeyword(article_url: {self.article_url}, keyword: '{self.keyword}')"
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')) # The 'user' referenced here is the name of the table for the model
def __repr__(self):
return f'<Post {self.body}>'
class User(UserMixin, db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(120), index=True, unique=False)
email = db.Column(db.String(120), index=True, unique=True)
paths = db.relationship('Path', backref='creator', lazy='dynamic')
steps = db.relationship('Step', backref='creator', lazy='dynamic')
def __repr__(self):
return '<User {}>'.format(self.email)
class User(UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), unique=True)
password_hash = db.Column(db.String(128))
def set_password(self, password):
self.password_hash = pbsha.hash(password)
def check_password(self, password):
return pbsha.verify(password, self.password_hash)
class ArticleTag(db.Model):
# references Article and Tag:
article_url = db.Column(db.String(2048),
db.ForeignKey('article.url'),
primary_key=True)
tag_text = db.Column(db.String(500),
db.ForeignKey('tag.text'),
primary_key=True)
def __repr__(self):
return f"ArticleTag(article_url: {self.article_url}, tag: '{self.tag_text}')"
class Attribute(db.Model):
"""Data model for representation of attributes in current diagram.
Use 'name'/'parent_name' composite as primary key because this combo is unique
"""
__tablename__ = 'attribute'
attribute = db.Column(db.String(200), primary_key=True)
attr_type = db.Column(db.String(10)) #field, method
date_created = db.Column(db.DateTime, default=datetime.utcnow)
class_name = db.Column(db.String(200), db.ForeignKey('class.name'), primary_key=True)
parent_class = relationship("Class", back_populates="class_attributes", foreign_keys=[class_name], primaryjoin='Class.name==Attribute.class_name')
class Tag(db.Model):
text = db.Column(db.String(500), primary_key=True)
is_confirmed = db.Column(db.Boolean, nullable=False)
time_added = db.Column(db.DateTime, nullable=False, default=datetime.now())
# referenced by other tables:
articleTags = db.relationship('ArticleTag',
backref='ArticleTag_tag',
lazy=True)
def __repr__(self):
return f"Tag('{self.text}', {'confirmed' if self.is_confirmed else 'potential'})"
class ArticleAction(db.Model):
# references Article:
article_url = db.Column(db.String(2048),
db.ForeignKey('article.url'),
primary_key=True)
action = db.Column(db.String(100), primary_key=True)
last_update_time = db.Column(db.DateTime,
nullable=False,
default=datetime.now())
def __repr__(self):
return f"ArticleAction(article_url: {self.article_url}, action: {self.action})"
class Class(db.Model):
"""Data model for representation of classes in current diagram.
Use 'name' as primary key because names are unique identifiers
"""
__tablename__ = 'class'
name = db.Column(db.String(200), primary_key=True)
date_created = db.Column(db.DateTime, default=datetime.utcnow)
x = db.Column(db.Integer())
y = db.Column(db.Integer())
class_attributes = relationship("Attribute", back_populates="parent_class", primaryjoin='Class.name==Attribute.class_name', cascade='all,delete-orphan')
class_relationships = relationship("Relationship", back_populates="parent_class", primaryjoin='Class.name==Relationship.from_name', cascade='all,delete-orphan')
class Employee(UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), unique=True)
password = db.Column(db.String(128))
email = db.Column(db.String(128))
def set_password(self, password):
self.password = pbsha.hash(password)
def check_password(self, password1):
return pbsha.verify(password1, self.password)
def set_email(self, email):
self.email = email
class FacultyUser(db.Model, UserMixin):
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))
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)
def __repr__(self):
return '<User {}>'.format(self.username)
class Relationship(db.Model):
"""Data model for representation of relationships in current diagram.
Use names 'from'/'to' as composite primary key because this combo is unique
"""
__tablename__ = 'relationship'
from_name = db.Column(db.String(200), db.ForeignKey('class.name'), primary_key=True)
to_name = db.Column(db.String(200), db.ForeignKey('class.name'), primary_key=True)
rel_type = db.Column(db.String(10)) # agg,comp,gen,none
parent_class = relationship("Class", back_populates="class_relationships", foreign_keys=[from_name, to_name], primaryjoin='Class.name==Relationship.from_name')
__mapper_args__ = {
'confirm_deleted_rows': False
}
class Employee(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(32))
age = db.Column(db.Integer)
ed = db.Column(db.String(64))
role = db.Column(db.String(64))
def to_dict(self):
return {
'id': self.id,
'name': self.name,
'age': self.age,
'ed': self.ed,
'role': self.role
}
class leaves(db.Model):
id = db.Column(db.Integer, primary_key = True)
student_username = db.Column(db.String(64), index = True, unique = False)
faculty_username = db.Column(db.String(64), index = True, unique = False)
from_date = db.Column(db.DateTime, index = True, unique = False)
to_date = db.Column(db.DateTime, index = True, unique = False)
reason = db.Column(db.String(64), index = True, unique = False)
type_of_leave = db.Column(db.String(64), index = True, unique = False)
leave_status = db.Column(db.String(20), index = True, unique = False)
class Registration(UserMixin, db.Model):
__tablename__ = 'registration'
reg_id=db.Column(db.Integer,primary_key=True, autoincrement=True)
fullname=db.Column(db.String(64))
mobile=db.Column(db.Integer)
email=db.Column(db.String(64))
def set_email(self, email):
self.email = email
def get_email(self):
return self.email
def set_mobile(self, mobile):
self.mobile = mobile
def get_mobile(self):
return self.mobile
class Step(db.Model):
__tablename__ = 'step'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(120), unique=False)
description = db.Column(db.String(400), unique=False)
link = db.Column(db.String(2048), unique=False)
step_order = db.Column(db.Integer, index=True, unique=False)
timestamp = db.Column(db.DateTime, default=datetime.utcnow)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
path_id = db.Column(db.Integer, db.ForeignKey('path.id'))
def __repr__(self):
return '<Step {}>'.format(self.name)
class Admin(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64))
password_hash = db.Column(db.String(128))
token = db.Column(db.String(128))
token_expiry = db.Column(db.DateTime)
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)
def get_token(self):
self.token = os.urandom(3).hex()
self.token_expiry = datetime.utcnow() + timedelta(seconds=360)
return self.token
def validate_token(self):
return (datetime.utcnow() + timedelta(seconds=60)) < self.token_expiry
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', lazy='dynamic')
about_me = db.Column(db.String(140))
last_seen = db.Column(db.DateTime, default=datetime.utcnow)
followed = db.relationship('User',
secondary=followers,
primaryjoin=(followers.c.follower_id == id),
secondaryjoin=(followers.c.followed_id == id),
backref=db.backref('followers', lazy='dynamic'),
lazy='dynamic')
def __repr__(self):
return f'<User {self.username}>'
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)
def avatar(self, size):
digest = md5(self.email.lower().encode('utf-8')).hexdigest()
return f'https://www.gravatar.com/avatar/{digest}?d=identicon&s={size}'
class Path(db.Model):
__tablename__ = 'path'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(120), index=True, unique=False)
description = db.Column(db.String(400), index=True, unique=False)
is_public = db.Column(db.Boolean, default=True, nullable=False)
timestamp = db.Column(db.DateTime, index=True, default=datetime.utcnow)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
steps = db.relationship('Step', backref='path', lazy='dynamic')
def __repr__(self):
return '<Path {}>'.format(self.name)
class User(db.Model, UserMixin
): # This class inherits from both 'db.model' and 'UserMixin'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(100), unique=True, nullable=False)
password = db.Column(db.String, nullable=False)
firstname = db.Column(db.String(100), nullable=False)
lastname = db.Column(db.String(100), nullable=False)
email = db.Column(db.String(120), nullable=False)
statesVisited = db.relationship('State',
secondary=statesVisited,
lazy='subquery',
backref=db.backref('users', lazy=True))
pictures = db.relationship('Picture')
def __repr__(
self
): # This method already has default behavior defined for all classes. This method returns a value to represent this class
return f"User('{self.firstname}', '{self.lastname}')"
class User(UserMixin, db.Model):
''' db.Model is a base class for all models from flask-sqlalchemy.
The UserMixin class includes generic implementations that are appropriate
for most user model classes( is_authenticated, is_active etc.)
'''
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))
# This field is defined only here for the one-to-many relationship (one user, multiple posts):
posts = db.relationship('Post', backref='author', lazy='dynamic')
about_me = db.Column(db.String(140))
last_seen = db.Column(db.DateTime, default=datetime.utcnow)
# Defining the followers table relationship; the .c. refers to the 'column' in the table:
followed = db.relationship('User', secondary=followers,
primaryjoin=(followers.c.follower_id == id),
secondaryjoin=(followers.c.followed_id == id),
backref=db.backref('followers', lazy='dynamic'), lazy='dynamic'
)
def __repr__(self):
return f'<User {self.username}>'
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)
def avatar(self, size):
# Encoding the string as bytes and then passing it to the hash function
digest = md5(self.email.lower().encode('utf-8')).hexdigest()
# The 'identicon' part is added to generate a default avatar for users who don't have one
return f'https://gravatar.com/avatar/{digest}?d=identicon&s={size}'
def follow(self, user):
if not self.is_following(user):
self.followed.append(user)
def unfollow(self, user):
if self.is_following(user):
self.followed.remove(user)
def is_following(self, user):
return self.followed.filter(followers.c.followed_id == user.id).count() > 0
def followed_posts(self):
followed = Post.query.join(
followers, followers.c.followed_id == Post.user_id).filter(
followers.c.follower_id == self.id)
own = Post.query.filter_by(user_id=self.id) # User's own posts
return followed.union(own).order_by(Post.timestamp.desc())
def get_reset_password_token(self, expires_in=600):
return jwt.encode(
{'reset_password': self.id, 'exp': time() + expires_in},
current_app.config['SECRET_KEY'], algorithm = 'HS256').decode('utf-8')
@staticmethod
def verify_reset_password_token(token):
try:
id = jwt.decode(token, current_app.config['SECRET_KEY'], algorithms=['HS256'])['reset_password']
except:
return
return User.query.get(id)
class Settings(db.Model):
"""Saves user settings. Currently only saves theme."""
name = db.Column(db.String(30), primary_key=True)
value = db.Column(db.String(50))
class advisor(db.Model):
student_username = db.Column(db.String(64), primary_key = True)
faculty_username = db.Column(db.String(64), index = True, unique = False)
from flask_login import UserMixin
from app_package import db, login
from hashlib import md5
from time import time
import jwt
''' Defining models for the database tables,
the fields and the data types (varchar, integer etc.).
So far, there are 3 tables in the db - User, Post and followers
'''
# This is an auxiliary table and has no data other than foreign keys, so no need for a model class for it:
followers = db.Table('followers',
db.Column('follower_id', db.Integer, db.ForeignKey('user.id')),
db.Column('followed_id', db.Integer, db.ForeignKey('user.id')))
class User(UserMixin, db.Model):
''' db.Model is a base class for all models from flask-sqlalchemy.
The UserMixin class includes generic implementations that are appropriate
for most user model classes( is_authenticated, is_active etc.)
'''
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))
class Role(UserMixin, db.Model):
__tablename__ = 'role'
role_id = db.Column(db.Integer, primary_key=True)
role_name = db.Column(db.String(64), unique=True)
