class User(UserMixin, db.Model):
__tablename__ = "user"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50), nullable=False, unique=False)
username = db.String(20)
email = db.Column(
db.String(40),
primary_key=False,
unique=False,
nullable=False)
password = db.Column(
db.String(200), primary_key=False, unique=False, nullable=False
)
posts = db.relationship("Post", backref="author")
def set_password(self, password):
self.password = generate_password_hash(password, method="sha256")
def check_password_hash(self, password):
return check_password_hash(self.password, password)
def get_password(self):
return self.password
def __repr__(self):
return "<User {}>".format(self.name)
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):
id = db.Column(UUID(as_uuid=True),
default=gen_uuid,
primary_key=True,
unique=True,
index=True)
username = db.Column(db.String(80),
unique=True,
nullable=False,
index=True)
password = db.Column(db.Text, unique=True, nullable=False)
def check_password(self, password):
return bc.check_password_hash(self.password, password)
def set_password(self, password):
self.password = bc.generate_password_hash(
password.__str__()).decode('utf-8')
def __init__(self, *args, **kwargs):
if kwargs.get('id') is None:
kwargs['id'] = gen_uuid()
kwargs['password'] = bc.generate_password_hash(str(
kwargs['password'])).decode('utf-8')
super(User, self).__init__(**kwargs)
def __repr__(self):
return '<User id={}, username={}}>'.format(self.id, self.username)
class User(db.Model):
user_id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(256), nullable=False, unique=True)
password = db.Column(db.String(256), nullable=False)
email = db.Column(db.String(256), nullable=False)
verified = db.Column(db.Boolean, nullable=False)
enabled = db.Column(db.Boolean, nullable=False)
admin = db.Column(db.Boolean, nullable=False)
created = db.Column(db.DateTime, nullable=False)
touched = db.Column(db.DateTime, nullable=False)
def __init__(self, username, password, email, verified, enabled, admin):
self.username = username
self.password = password
self.email = email
self.verified = verified
self.enabled = enabled
self.admin = admin
self.created = datetime.datetime.utcnow()
self.touched = self.created
def check_password(self, password):
return check_password_hash(self.password, password)
def touch(self):
self.touched = datetime.datetime.utcnow()
db.session.commit()
def get_verification_link(self):
payload = get_serializer().dumps(self.user_id)
return url_for('verify_email', payload=payload, _external=True)
class AccessToken(db.Model):
access_token_id = db.Column(db.Integer, primary_key=True)
identity_token_id = db.Column(db.Integer, db.ForeignKey(IdentityToken.identity_token_id), nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey(User.user_id), nullable=False, index=True)
token = db.Column(db.String(256), nullable=False, unique=True)
enabled = db.Column(db.Boolean, nullable=False)
client_addr = db.Column(db.String(256), nullable=False)
client_timestamp = db.Column(db.DateTime, nullable=False)
server_addr = db.Column(db.String(256), nullable=True)
server_timestamp = db.Column(db.DateTime, nullable=True)
identity_token = db.relationship(IdentityToken, backref=db.backref('access_tokens', lazy='dynamic'))
user = db.relationship(User, backref=db.backref('access_tokens', lazy='dynamic'))
def __init__(self, identity_token, user, token, enabled, client_addr, client_timestamp, server_addr, server_timestamp):
self.identity_token = identity_token
self.user = user
self.token = token
self.enabled = enabled
self.client_addr = client_addr
self.client_timestamp = client_timestamp
self.server_addr = server_addr
self.server_timestamp = server_timestamp
@property
def server_addr_str(self):
known_servers = {
'162.243.195.82': 'michaelfogleman.com',
}
return known_servers.get(self.server_addr, self.server_addr)
@property
def age(self):
return datetime.datetime.utcnow() - self.client_timestamp
def check_token(self, token, max_age):
print("checking token:", token)
if self.age > max_age:
return False
return check_password_hash(self.token, token)
class Stream(db.Model):
""" Model for storing Stream related details. """
__tablename__ = "streams"
stream_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
stream_name = db.Column(db.VARCHAR(60), unique=True, nullable=False)
stream_desc = db.Column(db.String(255), nullable=True)
date_added = db.Column(db.DateTime, nullable=False)
created_by = db.Column(db.Integer, db.ForeignKey('users.id'))
questions = db.relationship('Question', backref='stream', lazy='dynamic')
def __init__(self, stream_name, created_by, stream_desc=""):
self.stream_name = stream_name
self.stream_desc = stream_desc
self.created_by = created_by
self.date_added = datetime.datetime.now()
class IdentityToken(db.Model):
identity_token_id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer,
db.ForeignKey(User.user_id),
nullable=False,
index=True)
name = db.Column(db.String(256), nullable=False)
token = db.Column(db.String(256), nullable=False)
enabled = db.Column(db.Boolean, nullable=False)
created = db.Column(db.DateTime, nullable=False)
touched = db.Column(db.DateTime, nullable=False)
user = db.relationship(User,
backref=db.backref('identity_tokens',
lazy='dynamic'))
def __init__(self, user, name, token, enabled):
self.user = user
self.name = name
self.token = token
self.enabled = enabled
self.created = datetime.datetime.utcnow()
self.touched = self.created
def check_token(self, token):
return check_password_hash(self.token, token)
def touch(self):
self.touched = datetime.datetime.utcnow()
db.session.commit()
class Account(db.Model):
__tablename__ = 'accounts'
id = db.Column(db.Integer, primary_key=True)
login = db.Column(db.String(20))
admin = db.Column(db.Integer)
password_hash = db.Column(db.String(128))
access_token = db.Column(db.String(512))
refresh_token = db.Column(db.String(512))
code = db.Column(db.String(512))
class User(db.Model):
id = db.Column(db.String, primary_key=True)
name = db.Column(db.String, index=True)
email = db.Column(db.String, index=True, unique=True)
password_hash = db.Column(db.String)
email_verification_key = db.Column(db.String)
last_login = db.Column(db.DateTime)
def __init__(self, id, email, password, name):
self.id = id.lower()
self.name = name
self.set_email(email.lower())
self.set_password(password)
last_login = None
def set_email(self, email):
self.email = email
self.email_verification_key = str(uuid4())
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)
@property
def activated(self):
return self.last_login is not None
@property
def email_verified(self):
return not self.email_verification_key
def __repr__(self):
return '<User {}>'.format(self.id)
class Token(db.Model):
id = db.Column(UUID(as_uuid=True), primary_key=True, index=True)
sub = db.Column(UUID(as_uuid=True),
db.ForeignKey('user.id', ondelete='CASCADE'),
nullable=False)
exp = db.Column(db.DateTime(), nullable=False)
status = db.Column(db.Enum(TokenEnum), nullable=False)
def set_inactive(self):
self.status = TokenEnum.INACTIVE
def __init__(self, token=None, *args, **kwargs):
if token is not None:
kwargs['id'] = hash_token_to_uuid(token)
payload = jwt.decode(token, verify=False)
kwargs['sub'] = uuid.UUID(int=int(payload['sub']))
kwargs['exp'] = datetime.utcfromtimestamp(payload['exp'])
kwargs['status'] = TokenEnum.ACTIVE
super(Token, self).__init__(**kwargs)
def __repr__(self):
return '<Token id={}, sub={}>'.format(self.id, self.sub)
class Question(db.Model):
""" Model for storing Question related details. """
__tablename__ = "questions"
question_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
question_name = db.Column(db.VARCHAR(12), unique=True, nullable=False)
question_data = db.Column(db.JSON, nullable=True)
date_added = db.Column(db.DateTime, nullable=False)
stream_id = db.Column(db.Integer, db.ForeignKey('streams.stream_id'))
created_by = db.Column(db.Integer, unique=False, nullable=False)
def __init__(self, stream_name, stream_desc, stream_id, created_by):
self.question_name = stream_name
self.question_desc = stream_desc
self.created_by = created_by
self.stream_id = stream_id
self.date_added = datetime.datetime.now()
class Question(db.Model):
""" Model for storing Question related details. """
__tablename__ = "questions"
question_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
question_name = db.Column(db.VARCHAR(64), unique=False, nullable=False)
question_data = db.Column(db.JSON, nullable=True)
date_added = db.Column(db.DateTime, nullable=False)
stream_id = db.Column(db.Integer, db.ForeignKey('streams.stream_id'))
created_by = db.Column(db.Integer, unique=False, nullable=False)
def __init__(self, question_name, question_data, stream_id, created_by):
self.question_name = question_name
self.question_data = question_data
self.created_by = created_by
self.stream_id = stream_id
self.date_added = datetime.datetime.now()
def as_dict(self):
return {c.name: getattr(self, c.name) for c in self.__table__.columns}
class User(db.Model):
""" User Model for storing user related details """
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.VARCHAR(16), unique=True, nullable=False)
email = db.Column(db.String(255), unique=True, nullable=False)
password = db.Column(db.String(255), nullable=False)
registered_on = db.Column(db.DateTime, nullable=False)
admin = db.Column(db.Boolean, nullable=False, default=False)
last_login = db.Column(db.DateTime, nullable=True)
streams = db.relationship('Stream', backref='user', lazy='dynamic')
def as_dict(self):
return {c.name: getattr(self, c.name) for c in self.__table__.columns}
def __init__(self, email, username, password, admin=False):
self.email = email
self.username = username
self.password = bcrypt.generate_password_hash(
password, app.config.get('BCRYPT_LOG_ROUNDS')).decode()
self.registered_on = datetime.datetime.now()
self.admin = admin
@staticmethod
def encode_access_token(user_id):
"""
Generates the Access Token
:return: string
"""
try:
payload = {
'exp':
datetime.datetime.utcnow() +
datetime.timedelta(days=0, seconds=5),
'iat':
datetime.datetime.utcnow(),
'sub':
user_id,
'type':
'access'
}
return jwt.encode(payload,
app.config.get('SECRET_KEY'),
algorithm='HS256')
except Exception as e:
return e
def encode_refresh_token(self, user_id):
"""
Generates the Refresh Token
:return: string
"""
try:
payload = {
'exp':
datetime.datetime.utcnow() +
datetime.timedelta(days=1, seconds=5),
'iat':
datetime.datetime.utcnow(),
'sub':
user_id,
'type':
'refresh'
}
return jwt.encode(payload,
app.config.get('SECRET_KEY'),
algorithm='HS256')
except Exception as e:
return e
@staticmethod
def decode_token(token, type_of_token):
"""
Validates the access token
:param auth_token:
:return: integer|string
"""
try:
payload = jwt.decode(token, app.config.get('SECRET_KEY'))
if type_of_token != payload['type']:
return 'Provide Valid ' + type_of_token + ' token.'
if payload['type'] == 'refresh':
is_blacklisted_token = BlacklistToken.check_blacklist(token)
if is_blacklisted_token:
return 'Blacklisted'
return {'sub': payload['sub'], 'type': payload['type']}
except jwt.ExpiredSignatureError:
return 'Expired'
except jwt.InvalidTokenError:
return 'Invalid'
class User(UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(100), unique=True)
email = db.Column(db.String(100), unique=True)
password = db.Column(db.String(100))
class Token(db.Model):
__tablename__ = 'tokens'
id = db.Column(db.Integer, primary_key=True)
source_app = db.Column(db.String(64))
request_app = db.Column(db.String(64))
access_token = db.Column(db.String(512))