class CurrentPrice(ResourceMixin, db.Model):
__tablename__ = 'current_prices'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
data = db.Column(JSONB, nullable=False)
def __init__(self, **kwargs):
super(CurrentPrice, self).__init__(**kwargs)
class MarketSummary(ResourceMixin, db.Model):
__tablename__ = 'market_summ'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
data = db.Column(JSONB, nullable=False)
def __init__(self, **kwargs):
super(MarketSummary, self).__init__(**kwargs)
class Insight(ResourceMixin, db.Model):
__tablename__ = 'insights'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
ticker = db.Column(db.String, nullable=False)
data = db.Column(JSONB, nullable=False)
def __init__(self, **kwargs):
super(Insight, self).__init__(**kwargs)
class PL(ResourceMixin, db.Model):
__tablename__ = 'pl'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id',
onupdate='CASCADE',
ondelete='CASCADE'),
index=True, nullable=False)
data = db.Column(JSONB, nullable=False)
users = db.relationship('User', backref='pl')
def __init__(self, **kwargs):
super(PL, self).__init__(**kwargs)
class ResourceMixin(object):
# Keep track when records are created and updated.
created_on = db.Column(AwareDateTime(), default=tzware_datetime)
updated_on = db.Column(AwareDateTime(),
default=tzware_datetime,
onupdate=tzware_datetime)
def save(self):
"""
Save a model instance.
:return: Model instance
"""
db.session.add(self)
db.session.commit()
return self
def delete(self):
"""
Delete a model instance.
:return: db.session.commit()'s result
"""
db.session.delete(self)
return db.session.commit()
def __str__(self):
"""
Create a human readable version of a class instance.
:return: self
"""
obj_id = hex(id(self))
columns = self.__table__.c.keys()
values = ', '.join("%s=%r" % (n, getattr(self, n)) for n in columns)
return '<%s %s(%s)>' % (obj_id, self.__class__.__name__, values)
class Holding(ResourceMixin, db.Model):
__tablename__ = 'holdings'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id',
onupdate='CASCADE',
ondelete='CASCADE'),
index=True, nullable=False)
type = db.Column(db.Text, nullable=False)
ticker = db.Column(db.String(5), nullable=False)
quantity = db.Column(db.Integer, nullable=False)
price = db.Column(db.Float, nullable=False)
rpl = db.Column(db.Float, nullable=True)
total_spending = db.Column(db.Float, nullable=True)
date = db.Column(db.DateTime, nullable=False)
users = db.relationship('User', backref='holdings')
def __init__(self, **kwargs):
super(Holding, self).__init__(**kwargs)
@classmethod
def initialize_update_market_data(cls):
"""
Updates market data in the background.
"""
# This prevents circular imports.
from beatthemarket.blueprints.portfolio.tasks import (
update_market_data)
update_market_data.delay()
return "Celery Work Success"
@property
def __repr__(self):
return f"<Holding {self.user_id} {self.type} {self.ticker} {self.quantity} {self.price} {self.date} >"
class User(UserMixin, ResourceMixin, db.Model):
ROLE = OrderedDict([
('member', 'Member'),
('admin', 'Admin')
])
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True, autoincrement=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='')
# 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 get_user_id(cls, id):
"""Return user instance of id, return None if not exist"""
try:
return cls(id)
except UserWarning:
return None
@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
"""
# Logger
# current_app.logger.debug(f"{identity} has tried to login")
return User.query.filter(or_(User.email == identity,
User.username == identity)).first()
@classmethod
def encrypt_password(cls, plaintext_password):
"""
Hash a plaintext string using bcrypt
:param plaintext_password: Password in plain text
:type plaintext_password: str
:return: str
"""
if plaintext_password:
return bcrypt.generate_password_hash(plaintext_password).decode(
'utf8')
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 beatthemarket.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 bcrypt.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()