class Vote(Model):
"""
This model holds information about a votes casted by user on stories
"""
__tablename__ = "vote"
id = Column(db.Integer, primary_key=True)
story_id = Column(db.String(128))
user_id = Column(db.Integer, db.ForeignKey("user.id"))
value = Column(db.Integer)
def __init__(self, story_id, user_id, value):
self.story_id = story_id
self.user_id = user_id
self.value = value
@classmethod
def fetch_user_votes(cls, user_id):
return cls.query.filter_by(user_id=user_id).all()
def save(self):
"""
Save a user to the database.
This includes creating a new user and editing one.
"""
db.session.add(self)
db.session.commit()
class Comment(Model):
"""
This model represents a comment on a given note
"""
__tablename__ = "comment"
id = Column(db.Integer, primary_key=True)
story_id = Column(db.String(128))
user_id = Column(db.Integer, db.ForeignKey("user.id"))
content = Column(db.Integer)
def __init__(self, story_id, user_id, content):
self.story_id = story_id
self.user_id = user_id
self.content = content
@classmethod
def fetch_user_comments(cls, user_id):
return cls.query.filter_by(user_id=user_id).all()
@classmethod
def fetch_post_comments(cls, post_id):
return cls.query.filter_by(post_id=post_id).all()
def save(self):
"""
Save a comment to the database.
"""
db.session.add(self)
db.session.commit()
class RevokedToken(Model):
"""
This model holds information about revoked tokens, users who have logged out
"""
__tablename__ = "revoked_tokens"
id = Column(db.Integer, primary_key=True)
jti = Column(db.String(120))
def add(self):
db.session.add(self)
db.session.commit()
@classmethod
def is_jti_blacklisted(cls, jti):
query = cls.query.filter_by(jti=jti).first()
return bool(query)
class User(Model):
"""
This model holds information about a user registered
"""
__tablename__ = "user"
id = Column(db.Integer, primary_key=True)
name = Column(db.String(80), nullable=False)
password = Column(db.String(128))
email = Column(db.String(100), nullable=False, unique=True)
date = Column(db.DateTime, default=datetime.now())
votes = db.relationship("Vote", backref=db.backref("user"))
type = Column(db.String(50), default="remote")
def __init__(self, name, email, password, _type="remote"):
"""
Initializes the user instance
"""
self.name = name
self.email = email
if password:
self.password = Bcrypt().generate_password_hash(password).decode()
self.type = _type
def __repr__(self):
"""
Returns the object reprensentation
"""
return "<User %r>" % self.name
def to_json(self):
"""
Returns a JSON object
:return: user JSON object
"""
user_json = {"name": self.name, "email": self.email, "date": self.date}
return user_json
@classmethod
def find_by_email(cls, email):
return cls.query.filter_by(email=email).first()
def verify_password(self, password):
"""
Verify the password
:param password: password for verification
"""
return Bcrypt().check_password_hash(self.password, password)
def save(self):
"""
Save a user to the database.
This includes creating a new user and editing one.
"""
db.session.add(self)
db.session.commit()
class User(Model):
"""
This model holds information about a user registered
"""
__tablename__ = 'user'
id = Column(db.Integer, primary_key=True)
name = Column(db.String(80), nullable=False)
password = Column(db.String(128))
email = Column(db.String(100), nullable=False, unique=True)
date = Column(db.DateTime, default=datetime.now())
type = Column(db.String(50), default='remote')
def __init__(self, name, email, password, _type='remote'):
"""
Initializes the user instance
"""
self.name = name
self.email = email
if (password):
self.password = Bcrypt().generate_password_hash(password).decode()
self.type = _type
def __repr__(self):
"""
Returns the object reprensentation
"""
return '<User %r>' % self.name
def generate_auth_token(self, expiration, user_id, user_name):
"""
Generate authorization token
"""
try:
# set up a payload with an expiration time
payload = {
'exp': datetime.utcnow() + timedelta(seconds=expiration),
'iat': datetime.utcnow(),
'sub': user_id,
'name': user_name
}
# create the byte string token using the payload and the SECRET key
jwt_string = jwt.encode(payload,
current_app.config.get('SECRET_KEY'),
algorithm='HS256')
return jwt_string
except Exception as e:
# return an error in string format if an exception occurs
return str(e)
def to_json(self):
"""
Returns a JSON object
:return: user JSON object
"""
user_json = {
'name': self.name,
'password': self.password,
'email': self.email,
'date': self.date
}
return user_json
@staticmethod
def verify_auth_token(token):
"""
Verification of authorization token
:param token: token for verification
"""
try:
# try to decode the token using our SECRET variable
payload = jwt.decode(token, current_app.config.get('SECRET_KEY'))
return payload['sub']
except jwt.ExpiredSignatureError:
# the token is expired, return an error string
return "Expired token. Please login to get a new token"
except jwt.InvalidTokenError:
# the token is invalid, return an error string
return "Invalid token. Please register or login"
def verify_password(self, password):
"""
Verify the password
:param password: password for verification
"""
return Bcrypt().check_password_hash(self.password, password)
def save(self):
"""
Save a user to the database.
This includes creating a new user and editing one.
"""
db.session.add(self)
db.session.commit()
class User(Model):
"""
This model holds information about a user registered
"""
__tablename__ = "user"
id = Column(db.Integer, primary_key=True)
name = Column(db.String(80), nullable=False)
password = Column(db.String(128))
verification_token = Column(db.String(128), nullable=False, unique=True)
email = Column(db.String(100), nullable=False, unique=True)
date = Column(db.DateTime, default=datetime.now())
votes = db.relationship("Vote", backref=db.backref("user"))
type = Column(db.String(50), default="remote")
role = Column(db.String(10), default="user")
def __init__(self, name, email, password, role="user", _type="remote"):
"""
Initializes the user instance
"""
self.name = name
self.email = email
self.verification_token = User.generate_token()
if password:
self.password = User.generate_password_hash(password)
self.type = _type
self.role = role
def __repr__(self):
"""
Returns the object reprensentation
"""
return "<User %r>" % self.name
def to_json(self):
"""
Returns a JSON object
:return: user JSON object
"""
user_json = {"name": self.name, "email": self.email, "date": self.date}
return user_json
@classmethod
def find_by_email(cls, email):
return cls.query.filter_by(email=email).first()
@classmethod
def find_by_user_id(cls, _id):
return cls.query.filter_by(id=_id).first()
@classmethod
def find_by_verification_token(cls, verification_token):
return cls.query.filter_by(
verification_token=verification_token).first()
@classmethod
def verify_admin(cls, email):
"""
Verify admin role
"""
try:
query = cls.query.filter_by(email=email, role="admin").first()
return query
except Exception as err:
print("Error: ", err)
@staticmethod
def generate_token():
"""
Returns a random token
"""
return uuid4().hex
@staticmethod
def generate_password_hash(password):
"""
Returns hash of password
"""
return Bcrypt().generate_password_hash(password).decode()
def verify_password(self, password):
"""
Verify the password
:param password: password for verification
"""
return Bcrypt().check_password_hash(self.password, password)
def save(self):
"""
Save a user to the database.
This includes creating a new user and editing one.
"""
db.session.add(self)
db.session.commit()