class Coupon(ResourceMixin, db.Model):
DURATION = OrderedDict([('forever', 'Forever'), ('once', 'Once'),
('repeating', 'Repeating')])
__tablename__ = 'coupons'
id = db.Column(db.Integer, primary_key=True)
# Coupon details.
code = db.Column(db.String(128), index=True, unique=True)
duration = db.Column(db.Enum(*DURATION, name='duration_types'),
index=True,
nullable=False,
server_default='forever')
amount_off = db.Column(db.Integer())
percent_off = db.Column(db.Integer())
currency = db.Column(db.String(8))
duration_in_months = db.Column(db.Integer())
max_redemptions = db.Column(db.Integer(), index=True)
redeem_by = db.Column(AwareDateTime(), index=True)
times_redeemed = db.Column(db.Integer(),
index=True,
nullable=False,
default=0)
valid = db.Column(db.Boolean(), nullable=False, server_default='1')
def __init__(self, **kwargs):
if self.code:
self.code = self.code.upper()
else:
self.code = Coupon.random_coupon_code()
# Call Flask-SQLAlchemy's constructor.
super(Coupon, self).__init__(**kwargs)
@hybrid_property
def redeemable(self):
"""
Return coupons that are still redeemable. Coupons will become invalid
once they run out on save. We want to explicitly do a date check to
avoid having to hit Stripe's API to get back potentially valid codes.
:return: SQLAlchemy query object
"""
is_redeemable = or_(self.redeem_by.is_(None),
self.redeem_by >= datetime.datetime.now(pytz.utc))
return and_(self.valid, is_redeemable)
@classmethod
def search(cls, query):
"""
Search a resource by 1 or more fields.
:param query: Search query
:type query: str
:return: SQLAlchemy filter
"""
if query == '':
return ''
#if not query:
# return ''
search_query = f'%{query}%'
return or_(Coupon.code.ilike(search_query))
@classmethod
def random_coupon_code(cls):
"""
Create a human readable random coupon code.
:return: str
"""
charset = string.digits + string.ascii_uppercase
charset = charset.replace('B', '').replace('I', '')
charset = charset.replace('O', '').replace('S', '')
charset = charset.replace('0', '').replace('1', '')
random_chars = ''.join(choice(charset) for _ in range(14))
coupon_code = f'{random_chars[0:4]}-{random_chars[5:9]}-{random_chars[10:14]}'
return coupon_code
@classmethod
def expire_old_coupons(cls, compare_datetime=None):
"""
Invalidate coupons that are past their redeem date.
:param compare_datetime: Time to compare at
:type compare_datetime: date
:return: The result of updating the records
"""
if compare_datetime is None:
compare_datetime = datetime.datetime.now(pytz.utc)
Coupon.query.filter(Coupon.redeem_by <= compare_datetime) \
.update({Coupon.valid: not Coupon.valid})
return db.session.commit()
@classmethod
def create(cls, params):
"""
Return whether or not the coupon was created successfully.
:return: bool
"""
payment_params = params
payment_params['code'] = payment_params['code'].upper()
if payment_params.get('amount_off'):
payment_params['amount_off'] = \
dollars_to_cents(payment_params['amount_off'])
PaymentCoupon.create(**payment_params)
if 'id' in payment_params:
payment_params['code'] = payment_params['id']
del payment_params['id']
if 'redeem_by' in payment_params:
if payment_params.get('redeem_by') is not None:
params['redeem_by'] = payment_params.get('redeem_by').replace(
tzinfo=pytz.UTC)
coupon = Coupon(**payment_params)
db.session.add(coupon)
db.session.commit()
return True
@classmethod
def bulk_delete(cls, ids):
"""
Override the general bulk_delete method because we need to delete them
one at a time while also deleting them on Stripe.
:param ids: List of ids to be deleted
:type ids: list
:return: int
"""
delete_count = 0
for id in ids:
coupon = Coupon.query.get(id)
if coupon is None:
continue
stripe_response = PaymentCoupon.delete(coupon.code)
if stripe_response.get('deleted'):
coupon.delete()
delete_count += 1
return delete_count
@classmethod
def find_by_code(cls, code):
"""
Find a coupon by its code.
:param code: Coupon code to find
:type code: str
:return: Coupon instance
"""
formatted_code = code.upper()
coupon = Coupon.query.filter(Coupon.redeemable,
Coupon.code == formatted_code).first()
return coupon
def redeem(self):
"""
Update the redeem stats for this coupon.
:return: Result of saving the record
"""
self.times_redeemed += 1
if self.max_redemptions:
if self.times_redeemed >= self.max_redemptions:
self.valid = False
return db.session.commit()
def apply_discount_to(self, amount):
"""
Apply the discount to an amount.
:param amount: Amount in cents
:type amount: int
:return: int
"""
if self.amount_off:
amount -= self.amount_off
elif self.percent_off:
amount *= (1 - (self.percent_off * 0.01))
return int(amount)
def to_json(self):
"""
Return JSON fields to represent a coupon.
:return: dict
"""
params = {
'duration': self.duration,
'duration_in_months': self.duration_in_months
}
if self.amount_off:
params['amount_off'] = cents_to_dollars(self.amount_off)
if self.percent_off:
params['percent_off'] = self.percent_off
return params
class User(UserMixin, ResourceMixin, db.Model):
ROLE = OrderedDict([
('member', 'Member'),
('admin', 'Admin')
])
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
# Relationships.
credit_card = db.relationship(CreditCard, uselist=False, backref='users',
passive_deletes=True)
subscription = db.relationship(Subscription, uselist=False,
backref='users', passive_deletes=True)
invoices = db.relationship(Invoice, backref='users', passive_deletes=True)
# Authentication.
role = db.Column(db.Enum(*ROLE, name='role_types', native_enum=False),
index=True, nullable=False, server_default='member')
active = db.Column('is_active', db.Boolean(), nullable=False,
server_default='1')
username = db.Column(db.String(24), unique=True, index=True)
email = db.Column(db.String(255), unique=True, index=True, nullable=False,
server_default='')
password = db.Column(db.String(128), nullable=False, server_default='')
# Billing.
name = db.Column(db.String(128), index=True)
payment_id = db.Column(db.String(128), index=True)
cancelled_subscription_on = db.Column(AwareDateTime())
# Activity tracking.
sign_in_count = db.Column(db.Integer, nullable=False, default=0)
current_sign_in_on = db.Column(AwareDateTime())
current_sign_in_ip = db.Column(db.String(45))
last_sign_in_on = db.Column(AwareDateTime())
last_sign_in_ip = db.Column(db.String(45))
def __init__(self, **kwargs):
# Call Flask-SQLAlchemy's constructor.
super(User, self).__init__(**kwargs)
self.password = User.encrypt_password(kwargs.get('password', ''))
def __repr__(self):
"""
Create a human readable version of a User instance.
:return: self
"""
return f'<User {self.username}>'
@classmethod
def find_by_identity(cls, identity):
"""
Find a user by their e-mail or username.
:param identity: Email or username
:type identity: str
:return: User instance
"""
return User.query.filter(
(User.email == identity) | (User.username == identity)).first()
@classmethod
def encrypt_password(cls, plaintext_password):
"""
Hash a plaintext string using PBKDF2. This is good enough according
to the NIST (National Institute of Standards and Technology).
In other words while bcrypt might be superior in practice, if you use
PBKDF2 properly (which we are), then your passwords are safe.
:param plaintext_password: Password in plain text
:type plaintext_password: str
:return: str
"""
if plaintext_password:
return generate_password_hash(plaintext_password)
return None
@classmethod
def deserialize_token(cls, token):
"""
Obtain a user from de-serializing a signed token.
:param token: Signed token.
:type token: str
:return: User instance or None
"""
private_key = TimedJSONWebSignatureSerializer(
current_app.config['SECRET_KEY'])
try:
decoded_payload = private_key.loads(token)
return User.find_by_identity(decoded_payload.get('user_email'))
except Exception:
return None
@classmethod
def initialize_password_reset(cls, identity):
"""
Generate a token to reset the password for a specific user.
:param identity: User e-mail address or username
:type identity: str
:return: User instance
"""
u = User.find_by_identity(identity)
reset_token = u.serialize_token()
# This prevents circular imports.
from snakeeyes.blueprints.user.tasks import (
deliver_password_reset_email)
deliver_password_reset_email.delay(u.id, reset_token)
return u
def is_active(self):
"""
Return whether or not the user account is active, this satisfies
Flask-Login by overwriting the default value.
:return: bool
"""
return self.active
def get_auth_token(self):
"""
Return the user's auth token. Use their password as part of the token
because if the user changes their password we will want to invalidate
all of their logins across devices. It is completely fine to use
md5 here as nothing leaks.
This satisfies Flask-Login by providing a means to create a token.
:return: str
"""
private_key = current_app.config['SECRET_KEY']
serializer = URLSafeTimedSerializer(private_key)
data = [str(self.id), md5(self.password.encode('utf-8')).hexdigest()]
return serializer.dumps(data)
def authenticated(self, with_password=True, password=''):
"""
Ensure a user is authenticated, and optionally check their password.
:param with_password: Optionally check their password
:type with_password: bool
:param password: Optionally verify this as their password
:type password: str
:return: bool
"""
if with_password:
return check_password_hash(self.password, password)
return True
def serialize_token(self, expiration=3600):
"""
Sign and create a token that can be used for things such as resetting
a password or other tasks that involve a one off token.
:param expiration: Seconds until it expires, defaults to 1 hour
:type expiration: int
:return: JSON
"""
private_key = current_app.config['SECRET_KEY']
serializer = TimedJSONWebSignatureSerializer(private_key, expiration)
return serializer.dumps({'user_email': self.email}).decode('utf-8')
def update_activity_tracking(self, ip_address):
"""
Update various fields on the user that's related to meta data on their
account, such as the sign in count and ip address, etc..
:param ip_address: IP address
:type ip_address: str
:return: SQLAlchemy commit results
"""
self.sign_in_count += 1
self.last_sign_in_on = self.current_sign_in_on
self.last_sign_in_ip = self.current_sign_in_ip
self.current_sign_in_on = datetime.datetime.now(pytz.utc)
self.current_sign_in_ip = ip_address
return self.save()
@classmethod
def search(cls, query):
"""
Search a resource by 1 or more fields.
:param query: Search query
:type query: str
:return: SQLAlchemy filter
"""
search_query = '%{0}%'.format(query)
search_chain = (User.email.ilike(search_query),
User.username.ilike(search_query))
return or_(*search_chain)
@classmethod
def is_last_admin(cls, user, new_role, new_active):
"""
Determine whether or not this user is the last admin account.
:param user: User being tested
:type user: User
:param new_role: New role being set
:type new_role: str
:param new_active: New active status being set
:type new_active: bool
:return: bool
"""
is_changing_roles = user.role == 'admin' and new_role != 'admin'
is_changing_active = user.active is True and new_active is None
if is_changing_roles or is_changing_active:
admin_count = User.query.filter(User.role == 'admin').count()
active_count = User.query.filter(User.is_active is True).count()
if admin_count == 1 or active_count == 1:
return True
return False
@classmethod
def bulk_delete(cls, ids):
"""
Override the general bulk_delete method because we need to delete them
one at a time while also deleting them on Stripe.
:param ids: List of ids to be deleted
:type ids: list
:return: int
"""
delete_count = 0
for id in ids:
user = User.query.get(id)
if user is None:
continue
if user.payment_id is None:
user.delete()
else:
subscription = Subscription()
cancelled = subscription.cancel(user=user)
# If successful, delete it locally.
if cancelled:
user.delete()
delete_count += 1
return delete_count
class Coupon(db.Model):
DURATION = OrderedDict([('once', 'Once'), ('repeating', 'Repeating'),
('forever', 'Forever')])
__tablename__ = 'coupons'
id = db.Column(db.Integer, primary_key=True)
# Coupon details.
code = db.Column(db.String(128), index=True, unique=True)
duration = db.Column(db.Enum(*DURATION, name='duration_types'),
index=True,
nullable=False,
default='forever')
amount_off = db.Column(db.Integer())
percent_off = db.Column(db.Integer())
currency = db.Column(db.String(8))
duration_in_months = db.Column(db.Integer())
max_redemptions = db.Column(db.Integer(), index=True)
redeem_by = db.Column(db.DateTime(), default=datetime.datetime.utcnow)
times_redeemed = db.Column(db.Integer(),
index=True,
nullable=False,
default=0)
valid = db.Column(db.Boolean(), nullable=False, server_default='1')
created_on = db.Column(db.DateTime(), default=datetime.datetime.utcnow)
def __init__(self, **kwargs):
if self.code:
self.code = code.upper()
else:
self.code = Coupon.random_coupon_code()
super(Coupon, self).__init__(**kwargs)
@hybrid_property
def redeemable(self):
"""
Returns coupon code that are still valid.
"""
is_redeemable = or_(self.redeem_by.is_(None),
self.redeem_by >= datetime.datetime.now)
return and_(self.valid, is_redeemable)
@classmethod
def search(cls, query):
"""
search resources by one or more filed
"""
if not query:
return ''
search_query = '%{0}%'.format(query)
return or_(cls.code.ilike(search_query))
# search_query = '%{0}%'.format(query)
# search_chain = (User.email.ilike(search_query),
# User.username.ilike(search_query))
# return or_(*search_chain)
@classmethod
def random_coupon_code(cls):
"""
Create a human readable random code.
"""
charset = string.digits + string.ascii_uppercase
charset = charset.replace('B', '').replace('I', '')
charset = charset.replace('O', '').replace('S', '')
charset = charset.replace('0', '').replace('1', '')
random_chars = ''.join(choice(charset) for _ in range(0, 14))
coupon_code = '{}-{}-{}'.format(random_chars[0:4], random_chars[5:9],
random_chars[10:14])
return coupon_code
@classmethod
def expire_old_coupons(cls, compare_date=None):
"""
Invalidate coupon that has pass thier expire date
"""
if compare_date is None:
compare_date = datetime.datetime.now(pytz.utc)
cls.query.filter(cls.redeem_by < +compare_date).update(
{cls.valid: not cls.valid})
return db.session.commit()
@classmethod
def create(cls, params):
"""
Create a coupon code and return true is successful
"""
payment_params = params
payment_params['code'] = payment_params['code'].upper()
if payment_params.get('amount_off'):
payment_params['amount_off'] = dollars_to_cents(
payment_params['amount_off'])
PaymentCoupon.create(**payment_params)
# Stripe will save the coupon to id field on stripe while on our database, we want it to save on code field
if 'id' in payment_params:
payment_params['code'] = payment_params['id']
del payment_params['id']
# Converting th eunix time to day stim stamp that is acceptable by the databse
if 'redeem_by' in payment_params:
if payment_params.get('redeem_by') is not None:
params['redeem_by'] = payment_params.get('redeem_by').replace(
datetime.datetime.utcnow)
coupon = Coupon(**payment_params)
db.session.add(coupon)
db.session.commit()
return True
@classmethod
def bulk_delete(cls, ids):
"""
Override the general bulk delete method to delete coupon from application and stripe
"""
delete_count = 0
for id in ids:
coupon = Coupon.query.get(id)
print(coupon)
if coupon is None:
continue
# Delete on stripe
stripe_delete = PaymentCoupon.delete(coupon)
# If successful, delete it locally
if stripe_delete.get('deleted'):
db.session.delete(coupon)
delete_count += 1
return delete_count
@classmethod
def find_by_code(cls, code):
"""
Find a coupon by its code
"""
formatted_code = code.upper()
coupon = Coupon.query.filter(Coupon.redeemable,
Coupon.code == formatted_code).first()
return coupon
def redeem(self):
"""
Update redeem stats for this coupon
"""
self.times_redeemed += 1
if self.max_redemptions:
if self.times_redeemed >= self.max_redemptions:
self.valid = False
return db.session.commit()
def to_json(self):
"""
Retun JSON fields to represent a coupon
"""
params = {
'duration': self.duration,
'duration_in_months': self.duration_in_months
}
if self.amount_off:
params['amount_off'] = cent_to_dollar(self.amount_off)
if self.percent_off:
params['percent_off'] = self.percent_off
return params
@classmethod
def sort_by(cls, field, direction):
"""This help to sort the user base on the field column and direction. """
if field not in cls.__table__.columns:
field = "created_on"
if direction not in ('asc', 'desc'):
direction = 'asc'
return field, direction
@classmethod
def get_bulk_action_ids(cls, scope, ids, omit_ids=[], query=''):
"""Determine which id to be deleted."""
omit_ids = list(map(str, omit_ids))
if scope == 'all_search_result':
ids = cls.query.with_entities(cls.id).filter(cls.search(query))
ids = [str(item[0]) for item in ids]
if omit_ids:
ids = [id for id in ids if id not in omit_ids]
return ids
class User(UserMixin, ResourceMixin, db.Model):
ROLE = OrderedDict([
('member', 'Member'),
('admin', 'Admin')
])
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
# Authntication.
role = db.Column(db.Enum(*ROLE, name='role_types', native_enum=False),
index=True, nullable=False, server_default='member')
active = db.Column('is_active', db.Boolean(), nullable=False,
server_default='1')
username = db.Column(db.String(24), unique=True, index=True)
email = db.Column(db.String(255), unique=True, index=True, nullable=False,
server_default='')
password = db.Column(db.String(128), nullable=False, server_default='')
# Activity tracking.
sign_in_count = db.Column(db.Integer, nullable=False, default=0)
current_sign_in_on = db.Column(AwareDateTime())
current_sign_in_ip = db.Column(db.String(45))
last_sign_in_on = db.Column(AwareDateTime())
last_sign_in_ip = db.Column(db.String(45))
def __init__(self, **kwargs):
# Call Flask-SQLAlchemy's constructor
super(User, self).__init__(**kwargs)
self.password = User.encrypt_password(kwargs.get('password', ''))
@classmethod
def find_by_identity(cls, identity):
"""
Find a user by thier e-mail or username.
:param identity: Email or username
:type identity: str
:return: User instance
"""
return User.query.filter(
(User.email == identity) | (User.username == identity)).first()
@classmethod
def encrypt_password(cls, plaintext_password):
"""
Hash a plaintext string using PBKDF2. This is good enough according
to the NIST (National Institute of Standards and Technology).
In other words while bcrypt might be superior in practice, if you use
PBKDF2 properly (which we are), then your passwords are safe.
:param plaintext_password: Password in plain text
:type plaintext_password: str
:return: str
"""
if plaintext_password:
return generate_password_hash(plaintext_password)
return None
@classmethod
def deserialize_token(cls, token):
"""
Obtain a user from de-serializing a signed token.
:param token: Signed token.
:type token: str
:return: User instance or None
"""
private_key = TimedJSONWebSignatureSerializer(
current_app.config['SECRET_KEY'])
try:
decoded_payload = private_key.loads(token)
return User.find_by_identity(decoded_payload.get('user_email'))
except Exception:
return None
@classmethod
def initialize_password_reset(cls, identity):
"""
Generate a token to reset the password for a specific user.
:param identity: User e-mail address or username
:type identity: str
:return: User instance
"""
u = User.find_by_identity(identity)
reset_token = u.serialize_token()
# This prevents circular imports
from snakeeyes.blueprints.user.tasks import (
deliver_password_reset_email)
deliver_password_reset_email.delay(u.id, reset_token)
return u
def is_active(self):
"""
Return whether or not the user account is active, this satisfies
Flask-Login by overwriting the default value.
:return: bool
"""
return self.active
def get_auth_token(self):
"""
Return the user's auth token. Use their password as part of the token
because if the user changes their password we will want to invalidate
all of their logins across devices. It is completely fine to use md5
here as nothing leaks.
This satisfies Flask-Login by providing a means to create a token.
:return: str
"""
private_key = current_app.config['SECRET_KEY']
serializer = URLSafeTimedSerializer(private_key)
data = [str(self.id), md5(self.password.encode('utf-8')).hexdigest()]
return serializer.dumps(data)
def authenticated(self, with_password=True, password=''):
"""
Ensure a user is authenticated, and optionally check their password.
:param with_password: Optionally check their password
:param with_password: bool
:param password: Optionally verify this as their password
:param password: str
:return: bool
"""
if with_password:
return check_password_hash(self.password, password)
return True
def serialize_token(self, expiration=3600):
"""
Sign and create a token that can be used for things such as resetting
a password or other tasks that involve a one off token.
:param expiration: Seconds until it expires, defaults to 1 hour
:type expiration: int
:return: JSON
"""
private_key = current_app.config['SECRET_KEY']
serializer = TimedJSONWebSignatureSerializer(private_key, expiration)
return serializer.dumps({'user_email': self.email}).decode('utf-8')
def update_activity_tracking(self, ip_address):
"""
Update various fields on the user that's related to meta data on their
account, such as the sign in count and ip address, etc..
:param ip_address: IP address
:type ip_address: str
:return: SQLAlchemy commit results
"""
self.sign_in_count += 1
self.last_sign_in_on = self.current_sign_in_on
self.last_sign_in_ip = self.current_sign_in_ip
self.current_sign_in_on = datetime.datetime.now(pytz.utc)
self.current_sign_in_ip = ip_address
return self.save()
class User(UserMixin, db.Model):
__tablename__ = 'users'
ROLE = OrderedDict([
('member', "Member"),
("admin", "Admin")
])
# Unique idntification number
id = db.Column(db.Integer, primary_key = True)
# Credit card relationship
credit_card = db.relationship(CreditCard, uselist=False, backref='users', passive_deletes=True)
# Subscription relationship
subscription = db.relationship(Subscription, backref='users', uselist=False, passive_deletes=True)
# Invoic Relationships
invoice = db.relationship(Invoice, backref='users', passive_deletes=True)
# User credentials
role = db.Column(db.Enum(*ROLE, name = 'role_type', native_enum = False), nullable = False, default='member')
username = db.Column(db.String(128), nullable=True, unique=True)
email = db.Column(db.String(128), nullable=False, unique = True)
active = db.Column(db.Boolean, default = True, nullable=False)
hash_password = db.Column(db.String(240), nullable=False)
confirmed = db.Column(db.Boolean, default = False)
# User tracking information
sign_in_count = db.Column(db.Integer, default=0)
current_sign_in_on = db.Column(db.DateTime(), default=datetime.datetime.utcnow)
current_sign_in_ip = db.Column(db.String(24))
last_sign_in_on = db.Column(db.DateTime(), default=datetime.datetime.utcnow)
last_sign_in_ip = db.Column(db.String(24))
# Billing.
name = db.Column(db.String(128), index=True)
payment_id = db.Column(db.String(128), index=True)
cancelled_subscription_on = db.Column(db.DateTime(), default=datetime.datetime.utcnow)
# User run time
created_on = db.Column(db.DateTime(), default = datetime.datetime.utcnow)
updated_on = db.Column(db.DateTime(), default=datetime.datetime.utcnow, onupdate=datetime.datetime.utcnow)
@property
def password(self):
raise AttributeError('Password is not a readable attribute')
@password.setter
def password(self, password):
self.hash_password = generate_password_hash(password)
def verify_password(self, password):
return check_password_hash(self.hash_password, password)
def is_active(self):
return self.active
@classmethod
def search(cls, query):
"""
Search a resource by 1 or more fields.
:param query: Search query
:type query: str
:return: SQLAlchemy filter
"""
if not query:
return ''
search_query = '%{0}%'.format(query)
search_chain = (User.email.ilike(search_query),
User.username.ilike(search_query))
return or_(*search_chain)
@classmethod
def sort_by(cls, field, direction):
"""This help to sort the user base on the field column and direction. """
if field not in cls.__table__.columns:
field = "created_on"
if direction not in ('asc', 'desc'):
direction = 'asc'
return field, direction
@classmethod
def is_last_admin(cls, user, new_role, new_active):
"""This particular method will help to check if this particular user is the last admin."""
is_changing_role = user.role == 'admin' and new_role != 'admin'
is_changing_active = user.active is True and new_role is None
if is_changing_role or is_changing_active :
admin_count = User.query.filter(User.role == 'admin').count()
active_count = User.query.filter(User.is_active is True).count()
if admin_count == 1 or active_count == 1:
return True
return False
@classmethod
def get_bulk_action_id(cls, scope, ids, omit_id=None, query=''):
"""Determine bulk of id to be deleted."""
omit_id = list(map(str, omit_id))
if scope == 'all_search_result':
ids = User.query.with_entities(User.id).filter(User.search(query))
ids = [str(item[0]) for item in ids]
if omit_id:
ids = [id for id in ids if id not in omit_id]
return ids
@classmethod
def bulk_delete(cls, ids):
"""Delete selected user id"""
delete_count = User.query.filter(User.id.in_(ids)).delete(synchronize_session=False)
return delete_count
def track_user_activities(self, ip_address):
self.sign_in_count = +1
self.last_sign_in_on = self.current_sign_in_on
self.last_sign_in_ip = self.current_sign_in_ip
self.current_sign_in_ip = ip_address
self.current_sign_in_on = datetime.datetime.utcnow()
return True
def generate_token(self, expiration=3600):
s = TimedJSONWebSignatureSerializer(current_app.config["SECRET_KEY"], expires_in=expiration)
return s.dumps({"confirm": self.id}).decode('utf-8')
def verify_token(self,token):
s = TimedJSONWebSignatureSerializer(current_app.config['SECRET_KEY'])
try:
data = s.loads(token)
except:
return False
if data.get('confirm') != self.id:
return False
self.confirmed = True
db.session.add(self)
user = User.query.filter_by(id = data.get('confirm')).first()
return user.email
def generate_reset_token(self):
s = TimedJSONWebSignatureSerializer(current_app.config['SECRET_KEY'])
return s.dumps({'user_id': self.id})
@staticmethod
def confirm_reset_token(token):
s = TimedJSONWebSignatureSerializer(current_app.config['SECRET_KEY'])
try:
data = s.loads(token)
except:
return False
user = User.query.get(data.get('user_id'))
return user.id
@classmethod
def add_fake(cls):
from random import seed, randint, choice
from sqlalchemy.exc import IntegrityError
from snakeeyes.extensions import fake
users = []
seed()
while len(users) < 100:
u = User(
email = fake.email(),
username = fake.name()+str(randint(0, 300)),
active = bool(choice([True, False])),
password = '******',
sign_in_count = randint(0,20),
current_sign_in_on = fake.date_time_between(start_date='-1y', end_date='now'),
last_sign_in_ip = fake.ipv4(),
confirmed = bool(choice([True, False])),
current_sign_in_ip = fake.ipv4(),
last_sign_in_on = fake.date_time_between(start_date='-1y', end_date='now'),
created_on = fake.date_time_between(start_date='-15y', end_date='now'),
updated_on = fake.date_time_between(start_date='-15y', end_date='now')
)
users.append(u)
db.session.add(u)
try:
db.session.commit()
except IntegrityError:
db.session.rollback()
@classmethod
def add_admin(cls):
admin = User(email = '*****@*****.**',
password='******', confirmed=True, role='admin')
db.session.add(admin)
db.session.commit()
return True