class Address(db.Model):
""" User Model for storing user related details """
__tablename__ = "address"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(255), unique=True, nullable=False)
users = db.relationship('User', secondary='user_address')
class Product(db.Model):
__tablename__ = 'product'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String, nullable=False)
# currency = db.Column(CurrencyType, default=Currency('KSH'))
price = db.Column(db.Numeric(precision=9, scale=2))
discount = db.Column(db.Numeric(precision=5), nullable=True)
category_id = db.Column(db.Integer, db.ForeignKey("category.id"))
category = db.relationship(Category, backref="products")
slug = db.Column(db.String)
_email = db.Column(db.String)
@hybrid_property
def email(self):
return self._email
@email.setter
def email(self, email):
self._email = email
@observes('name')
def compute_slug(self, name):
"""
Computes the slug - shortened version of the title.
:param title: string, title to be shortened
:return: string, resulting slug
"""
self.slug = slugify(name)
class Tag(db.Model):
__tablename__ = 'tag'
id = db.Column(db.Integer, primary_key=True)
label = db.Column(db.String)
parent_id = db.Column(db.Integer, db.ForeignKey('tag.id'))
parent = db.relationship('Tag', remote_side=[id], backref='children')
text_array = db.Column(ARRAY(db.String))
# makes sense for product and product variations
class Category(db.Model):
__tablename__ = 'category'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100))
children = db.relationship(
'Category',
secondary=category_tree,
primaryjoin=(category_tree.c.parent_id == id),
secondaryjoin=(category_tree.c.children_id == id),
backref=db.backref('parents', lazy='dynamic'),
lazy='dynamic'
)
def __repr__(self):
return '<Category> {}'.format(self.id)
# a child has a list of parents
# a parent has a list of children
class User(db.Model, SQLAlchemyEmailMixin, SQLAlchemyPasswordMixin):
""" 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))
addresses = db.relationship('Address', secondary='user_address')
phones = db.relationship(Phone, backref='user', lazy='dynamic')
@property
def password(self):
raise AttributeError('password: write-only field')
@password.setter
def password(self, password):
self.password_hash = flask_bcrypt.generate_password_hash(
password).decode('utf-8')
def check_password(self, password):
return flask_bcrypt.check_password_hash(self.password_hash, password)
def encode_auth_token(self, 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)