class BlacklistToken(db.Model):
"""
Token Model for storing JWT tokens
"""
__tablename__ = 'blacklist_tokens'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
token = db.Column(db.String(500), unique=True, nullable=False)
blacklisted_on = db.Column(db.DateTime, nullable=False)
def __init__(self, token):
self.token = token
self.blacklisted_on = datetime.datetime.now()
def __repr__(self):
return '<id: token: {}'.format(self.token)
@staticmethod
def check_blacklist(auth_token):
# check whether auth token has been blacklisted
res = BlacklistToken.query.filter_by(token=str(auth_token)).first()
if res:
return True
else:
return False
class User(db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(128), nullable=False)
email = db.Column(db.String(128), nullable=False)
active = db.Column(db.Boolean(), default=False, nullable=False)
created_at = db.Column(db.DateTime, nullable=False)
def __init__(self, username, email):
self.username = username
self.email = email
self.created_at = datetime.datetime.utcnow()
class User(db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(128), unique=True, nullable=False)
email = db.Column(db.String(128), unique=True, nullable=False)
password = db.Column(db.String(255), nullable=False)
active = db.Column(db.Boolean(), default=True, nullable=False)
created_at = db.Column(db.DateTime, nullable=False)
admin = db.Column(db.Boolean, default=False, nullable=False)
def __init__(self,
username,
email,
password,
created_at=datetime.datetime.utcnow()):
self.username = username
self.email = email
self.password = bcrypt.generate_password_hash(
password, current_app.config.get('BCRYPT_LOG_ROUNDS')).decode()
self.created_at = created_at
def encode_auth_token(self, user_id):
"""Generates the auth token"""
try:
payload = {
'exp':
datetime.datetime.utcnow() + datetime.timedelta(
days=current_app.config.get('TOKEN_EXPIRATION_DAYS'),
seconds=current_app.config.get(
'TOKEN_EXPIRATION_SECONDS')),
'iat':
datetime.datetime.utcnow(),
'sub':
user_id
}
return jwt.encode(payload,
current_app.config.get('SECRET_KEY'),
algorithm='HS256')
except Exception as e:
return e
@staticmethod
def decode_auth_token(auth_token):
"""
Decodes the auth token - :param auth_token: - :return: integer|string
"""
try:
payload = jwt.decode(auth_token,
current_app.config.get('SECRET_KEY'))
return payload['sub']
except jwt.ExpiredSignatureError:
return 'Signature expired. Please log in again.'
except jwt.InvalidTokenError:
return 'Invalid token. Please log in again.'
class User(db.Model):
""" Class User model"""
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(10))
username = db.Column(db.String(30), unique=True, nullable=False)
email = db.Column(db.String(30), unique=True, nullable=False)
phone_number = db.Column(db.String(10))
country = db.Column(db.String(30))
password = db.Column(db.String(100), nullable=True)
registered_on = db.Column(db.DateTime, nullable=False)
confirmed = db.Column(db.Boolean, nullable=False, default=False)
confirmed_on = db.Column(db.DateTime, nullable=True)
password_reset_token = db.Column(db.String(100),
nullable=True,
default=None)
def __init__(self, username, email, password=None, **kwargs):
""" Create instance"""
db.Model.__init__(self, username=username, email=email, **kwargs)
if password:
self.password = self.set_password(password=password)
else:
self.password = None
self.registered_on = datetime.datetime.now()
def set_password(self, password):
""" the hashed password"""
return bcrypt.generate_password_hash(password)
def check_password(self, hashed_password):
""" check password"""
return bcrypt.check_password_hash(self.password, hashed_password)
def is_authenticated(self):
""" User is authenticated"""
return True
def is_active(self):
""" is active"""
return True
def get_id(self):
""" get id"""
return self.id
def __repr__(self):
""" get email"""
return self.email
class User(db.Model):
""" User Model for storing user related details """
__tablename__ = "user"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
email = db.Column(db.String(255), unique=True, nullable=False)
registered_on = db.Column(db.DateTime, nullable=False)
admin = db.Column(db.Boolean, nullable=False, default=False)
public_id = db.Column(db.String(100), unique=True)
username = db.Column(db.String(50), unique=True)
password_hash = db.Column(db.String(100))
@property
def password(self):
raise AttributeError('password: write-only field')
@password.setter
def password(self, password):
self.password_hash = bcrypt.generate_password_hash(password).decode(
'utf-8')
def check_password(self, password):
return bcrypt.check_password_hash(self.password_hash, password)
@staticmethod
def encode_auth_token(user_id):
"""
Generates the Auth Token
:return: string
"""
try:
payload = {
'exp':
datetime.datetime.utcnow() +
datetime.timedelta(days=1, seconds=5),
'iat':
datetime.datetime.utcnow(),
'sub':
user_id
}
return jwt.encode(payload, key, algorithm='HS256')
except Exception as e:
return e
@staticmethod
def decode_auth_token(auth_token):
"""
Decodes the auth token
:param auth_token:
:return: integer|string
"""
try:
payload = jwt.decode(auth_token, key)
is_blacklisted_token = BlacklistToken.check_blacklist(auth_token)
if is_blacklisted_token:
return 'Token blacklisted. Please log in again.'
else:
return payload['sub']
except jwt.ExpiredSignatureError:
return 'Signature expired. Please log in again.'
except jwt.InvalidTokenError:
return 'Invalid token. Please log in again.'
def __repr__(self):
return "<User '{}'>".format(self.username)
class UserModel(db.Model): index = db.Column(db.Integer,primary_key=True) username = db.Column(db.String,unique=True) password = db.Column(db.String) email = db.Column(db.String, unique=True)
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(20))