class Node(TableBase):
"""A bio-part which can be added to biopano."""
__tablename__ = 'node'
node_id = Column(String(256), primary_key=True)
node_name = Column(String(256))
node_catalog = Column(String(256))
class User(UserMixin, SurrogatePK, Model):
__tablename__ = 'users'
username = Column(db.String(80), unique=True, nullable=False) #..email
password = Column(db.Binary(128), nullable=True)
# ..
created = Column(db.DateTime, nullable=False, default=dt.datetime.utcnow)
is_active = Column(db.Boolean(), default=False)
is_admin = Column(db.Boolean(), default=False)
def __init__(self, username, password=None, **kwargs):
# ..
Model.__init__(self, username=username, password=password, **kwargs)
# ..
if password:
self.set_password(password)
else:
self.password = None
def __repr__(self):
"""Represent instance as a unique string."""
return '<User({username!r})>'.format(username=self.username)
def set_password(self, password):
"""Set password."""
self.password = bcrypt.generate_password_hash(password)
def check_password(self, value):
"""Check password."""
return bcrypt.check_password_hash(self.password, value)
class Label(Model, CRUDMixin):
__tablename__ = "labels"
id = Column(Integer, primary_key=True)
text = Column(String(250))
videoid = Column(Integer, ForeignKey(Video.id))
video = relationship(Video,
backref=backref("labels", cascade="all,delete"))
class RegistryType(CustomModelMixin, Model):
__tablename__ = 'registry_types'
name = Column(db.String(100), nullable=False)
slug = Column(db.String(100), nullable=False, unique=True)
is_active = Column(db.Boolean, default=True)
def __str__(self):
return self.name
class Test(Model):
id = Column(db.Integer, primary_key=True)
name = Column(db.String(80))
def __init__(self, name):
self.name = name
def __repr__(self):
return '<Test %r>' % self.name
class Donation(CustomModelMixin, Model):
__tablename__ = 'donations'
transaction_id = reference_col("transactions", nullable=False)
registry_id = reference_col("wedding_registries", nullable=False)
amount = Column(db.Float, nullable=False)
date_created = Column(db.DateTime, nullable=False, default=dt.datetime.utcnow)
registry = relationship("WeddingRegistry", backref=backref("donations", uselist=True))
transaction = relationship("Transaction", backref=backref("donations", uselist=True))
class TaskStatusRecord(Model, CRUDMixin):
__tablename__ = "task_status_records"
id = Column(Integer, primary_key=True)
task_id = Column(String(250))
classifier_id = Column(String(250))
update_time = Column(db.DateTime())
body = Column(String(5000))
'''
class BirthdayRegistry(HasOrders, HasProducts, HasAddress, RegistryBase):
__tablename__ = 'birthday_registries'
first_name = Column(db.String(100), nullable=False)
last_name = Column(db.String(100), nullable=False)
hashtag = Column(db.String(50), nullable=True)
message = Column(db.Text, nullable=True)
image = Column(db.Text, nullable=True)
admin_created_id = relationship("User")
created_by = relationship("User", backref="birthdays", primaryjoin="BirthdayRegistry.created_by_id==User.id")
@property
def url(self):
return "{}registry/birthdays/{}".format(request.url_root, self.slug)
def __str__(self):
return self.name
@property
def name(self):
return f"{self.first_name}'s Birthday"
@property
def image_url(self):
if self.image:
return True
return 'img/random/default_birthday.jpg'
@classmethod
def search(cls, term):
return cls.query.filter(cls.is_active.is_(True)).\
filter((cls.first_name.ilike(term)) | (cls.last_name.ilike(term)) | (cls.hashtag.ilike(term))
| (cls.slug.ilike(term)))
def unique_slug(self, slug):
if self.query.filter_by(slug=slug).first():
return f"{slug}-{str(uuid.uuid4()).split('-')[0]}"
return False
def generate_hashtag(self):
# check if hashtag has been provided
if not self.hashtag:
# if not
self.hashtag = f'#{self.first_name.title()}{str(self.event_date.year)}'
# check if first letter is hashtag
if self.hashtag[0] != '#':
self.hashtag = f'#{self.hashtag}'
def generate_slug(self):
# strip hashtag
slug = self.hashtag[1:]
# check if exists in database
check = self.unique_slug(slug) # if it exists, add uuid
self.slug = check.lower() if check else slug.lower()
class Attribute(Model, CRUDMixin):
__tablename__ = "attributes"
id = Column(Integer, primary_key=True)
text = Column(String(250))
labelid = Column(Integer, ForeignKey(Label.id))
label = relationship(Label,
backref=backref("attributes", cascade="all,delete"))
def __str__(self):
return self.text
class OrderItem(CustomModelMixin, Model):
__tablename__ = 'order_items'
order_id = reference_col("orders", nullable=False)
reg_product_id = reference_col("registry_products", nullable=False)
quantity = Column(db.Integer, default=1)
unit_price = Column(db.Float, nullable=False)
total_price = Column(db.Float, nullable=False)
order = relationship("Order")
registry_product = relationship("RegistryProducts")
class RegistryProducts(CustomModelMixin, Model):
__tablename__ = 'registry_products'
product_id = reference_col("products", nullable=False)
has_been_purchased = Column(db.Boolean, default=False)
registry_type = Column(db.Unicode(255))
registry_id = Column(db.Integer, nullable=False)
product = relationship("Product", backref=backref("registry_products", cascade="all, delete-orphan"))
def __str__(self):
return self.product.name
class Category(CustomModelMixin, Model):
__tablename__ = 'categories'
name = Column(db.String(100), nullable=False, unique=True)
slug = Column(db.String(100), nullable=False, unique=True)
created_by_id = reference_col("user", nullable=True)
date_created = Column(db.DateTime, nullable=False, default=dt.datetime.utcnow)
created_by = relationship("User")
def __repr__(self):
"""Represent instance as a string."""
return self.name
class Order(CustomModelMixin, Model):
__tablename__ = 'orders'
order_number = Column(db.String(255), unique=True)
transaction_id = reference_col("transactions", nullable=False)
status = Column(ChoiceType(STATUS, impl=db.String()))
date_created = Column(db.DateTime, nullable=False, default=dt.datetime.utcnow)
registry_type = Column(db.Unicode(255))
registry_id = Column(db.Integer, nullable=False)
transaction = relationship("Transaction", backref=backref("orders", uselist=True))
def generate_order_number(self):
self.order_number = f"ORD{dt.date.today().strftime('%Y%m%d')}00000{self.id}"
class RegistryDeliveryAddress(CustomModelMixin, Model):
__tablename__ = 'registry_delivery_addresses'
registry_id = reference_col("registries", nullable=False)
name = Column(db.String(100), nullable=False)
phone_number = db.Column(db.String(50), nullable=True)
address = Column(db.Text, nullable=False)
city = Column(db.String(50), nullable=False)
state = Column(db.String(50), nullable=False)
registry = relationship("Registry",
backref=backref("delivery",
uselist=False,
cascade="all, delete-orphan"))
class Article(CustomModelMixin, Model):
__tablename__ = 'articles'
title = Column(db.String(100), nullable=False)
slug = Column(db.String(100), nullable=False, unique=True)
summary = Column(db.Text(), nullable=False)
image = Column(db.Text, nullable=True)
content = Column(db.Text, nullable=False)
is_published = Column(db.Boolean, default=True)
view_count = Column(db.Integer, default=0)
created_by_id = reference_col("user", nullable=True)
date_created = Column(db.DateTime,
nullable=False,
default=dt.datetime.utcnow)
tags = relationship("Tag", secondary=articles_tags, backref='posts')
created_by = relationship("User")
def __repr__(self):
"""Represent instance as a string."""
return self.title
def publish(self):
self.is_published = True
return self.save()
def archive(self):
self.is_published = False
return self.save()
class PluginDocument(object):
"""Abstract class for all plugins to make their own document type."""
def __init__(self):
super().__init__()
if self.__class__ is PluginDocument:
raise NotImplementedError
id = Column(Integer(), primary_key=True)
@declared_attr
def owner(cls):
return Column(Integer(), ForeignKey('user.id'))
title = Column(String(256))
last_modified = Column(Integer())
description = Column(Text())
class ProductBundleItem(CustomModelMixin, Model):
__tablename__ = 'product_bundle_items'
name = Column(db.Text, nullable=False)
product_id = reference_col("products", nullable=False)
product = relationship("Product", backref="items")
class PanoDocument(TableBase, PluginDocument):
__tablename__ = 'pano'
def __init__(self, owner, title='Untitled', text=''):
super().__init__()
self.owner = owner
self.title = title
self.text = text
self.description = 'not support description'
text = Column(Text())
created = Column(Integer())
public = Column(Boolean())
comments = Column(Text())
praises = Column(Text())
class Newsletter(CustomModelMixin, Model):
__tablename__ = 'newsletter'
email = db.Column(db.String(255), unique=True)
date_created = Column(db.DateTime,
nullable=False,
default=dt.datetime.utcnow)
class Document(TableBase):
"""An object refer to an actual plugin-managed document.
Every actual document is not only saved in plugins' table, but also has an entry here, so that we can easily get all documents belong to a specific user."""
__tablename__ = 'document'
def __init__(self, plugin_name: str, doc: PluginDocument):
super().__init__()
self.owner = doc.owner
self.plugin_name = plugin_name
self.plugin_document_id = doc.id
document_id = Column(Integer(), primary_key=True)
owner = Column(Integer(), ForeignKey('user.id'))
plugin_name = Column(String(256))
plugin_document_id = Column(Integer())
class Tag(CustomModelMixin, Model):
__tablename__ = 'tags'
name = Column(db.String(50), nullable=False, unique=True)
slug = Column(db.String(50), nullable=False)
created_by_id = reference_col("user", nullable=True)
date_created = Column(db.DateTime, nullable=False, default=dt.datetime.utcnow)
created_by = relationship("User")
@classmethod
def get_popular_tags(cls, limit=4):
return cls.query.limit(limit)
def __repr__(self):
"""Represent instance as a string."""
return self.name
class ProductImage(CustomModelMixin, Model):
__tablename__ = 'product_images'
name = Column(db.Text, nullable=False)
product_id = reference_col("products", nullable=False)
is_main_image = Column(db.Boolean, default=False)
date_created = Column(db.DateTime, nullable=False, default=dt.datetime.utcnow)
product = relationship("Product", backref="images")
@property
def get_url(self):
return self.name
def __repr__(self):
"""Represent instance as a string."""
return self.name
class User(UserMixin, Model, CRUDMixin):
__tablename__ = "users"
id = Column(db.Integer, primary_key = True)
username = Column(db.String(250), index = True)
password = Column(db.String(250))
# one to many
videos = relationship('Video', backref='users')
# one to many
classifiers = relationship('Classifier', backref='users')
def get_id(self):
return self.id
def check_password(self, password):
return self.password == password
class AttributeAnnotation(Model, CRUDMixin):
__tablename__ = "attribute_annotations"
id = Column(Integer, primary_key=True)
pathid = Column(Integer, ForeignKey(Path.id))
path = relationship(Path,
backref=backref("attributes", cascade="all,delete"))
attributeid = Column(Integer, ForeignKey(Attribute.id))
attribute = relationship(Attribute)
frame = Column(Integer)
value = Column(Boolean, default=False)
def __repr__(self):
return ("AttributeAnnotation(pathid = {0}, "
"attributeid = {1}, "
"frame = {2}, "
"value = {3})").format(self.pathid, self.attributeid,
self.frame, self.value)
class Product(CustomModelMixin, Model):
__tablename__ = 'products'
name = Column(db.String(100), nullable=False)
slug = Column(db.String(100), nullable=False, unique=True)
category_id = reference_col("categories", nullable=False)
description = Column(db.Text, nullable=False)
sku = Column(db.String(50), nullable=True)
price = Column(db.Float, nullable=False)
is_available = Column(db.Boolean, default=True)
is_bundle = Column(db.Boolean, default=False)
created_by_id = reference_col("user", nullable=True)
date_created = Column(db.DateTime, nullable=False, default=dt.datetime.utcnow)
created_by = relationship("User")
category = relationship("Category")
def __repr__(self):
"""Represent instance as a string."""
return self.name
@property
def display_price(self):
return "NGN{:,.2f}".format(self.price)
def total_price(self, quantity):
return self.price * quantity
def display_total_price(self, quantity):
return "NGN{:,.2f}".format(self.total_price(quantity))
@property
def main_image(self):
if self.images:
for i in self.images:
if i.is_main_image:
return i
return self.images[0]
return
@property
def available_text(self):
if self.is_available:
return "In stock"
return "Out of stock"
@property
def to_json(self):
return {
'name': self.name,
'slug': self.slug,
'description': self.description,
'image': self.main_image.get_url
}
class User(TableBase, UserMixin):
"""A user."""
__tablename__ = 'user'
id = Column(Integer, primary_key=True)
email = Column(String(63), unique=True)
passwordhash = Column(String(127), nullable=False)
salt = Column(String(127), nullable=False)
username = Column(String(127))
if os.getenv('FLASK_TESTING'):
avatar = Column(String(16777215))
else:
avatar = Column(MEDIUMTEXT())
description = Column(Text())
education = Column(Text())
major = Column(Text())
def __init__(self, email, password, username):
self.email = email
self.set_password(password)
self.username = username
def set_password(self, password):
"""hash and save the password"""
self.salt = random_string(10)
s = hashlib.sha256()
s.update(password.encode('utf-8'))
s.update(self.salt.encode('utf-8'))
self.passwordhash = s.hexdigest()
def check_password(self, password):
"""hash and check the password"""
s = hashlib.sha256()
s.update(password.encode('utf-8'))
s.update(self.salt.encode('utf-8'))
return self.passwordhash == s.hexdigest()
@classmethod
def get_user_by_email(cls, email):
return session.query(cls).filter_by(email=email).first()
@classmethod
def get_user_by_id(cls, id):
return session.query(cls).get(id)
class RegistryBase(CustomModelMixin, Model):
__abstract__ = True
slug = Column(db.String(100), nullable=True)
date_created = Column(db.DateTime, nullable=False, default=dt.datetime.utcnow)
event_date = Column(db.Date, nullable=True)
is_active = Column(db.Boolean, default=True)
@property
def product_ids(self):
return [x.id for x in self.products]
@declared_attr
def created_by_id(cls):
return reference_col("user", nullable=True)
@declared_attr
def admin_created_id(cls):
return reference_col("user", nullable=True)
class Discount(CustomModelMixin, Model):
__tablename__ = 'discounts'
code = Column(db.String(50), nullable=False, unique=True)
amount = Column(db.Float, nullable=True)
percentage = Column(db.Float, nullable=True)
is_active = Column(db.Boolean, default=True)
created_by_id = reference_col("user", nullable=True)
date_created = Column(db.DateTime, nullable=False, default=dt.datetime.utcnow)
created_by = relationship("User")
def __repr__(self):
"""Represent instance as a string."""
return self.code
def get_discount_amount(self, price):
if self.amount:
return self.amount
return (self.percentage/100) * price
class TextFileDocument(TableBase, PluginDocument):
__tablename__ = 'textfile'
def __init__(self, owner, title='Untitled', text=''):
super().__init__()
self.owner = owner
self.title = title
self.text = text
self.description = 'not support description'
text = Column(Text())
class HoneymoonFund(CustomModelMixin, Model):
__tablename__ = 'honeymoon_funds'
registry_id = reference_col("registries", nullable=False)
message = Column(db.Text, nullable=True)
target_amount = Column(db.Float, nullable=True)
has_achieved_target = Column(db.Boolean, default=False)
date_target_achieved = Column(db.DateTime, nullable=True)
has_been_paid = Column(db.Boolean, default=False)
date_paid_status_updated = Column(db.DateTime, nullable=True)
admin_updated_id = reference_col("user", nullable=True)
admin_updated_by = relationship("User")
registry = relationship("Registry",
backref=backref('fund', uselist=False),
uselist=False)
def __str__(self):
return self.registry.name
@staticmethod
def format_price(price):
return "NGN{:,.2f}".format(price)
@property
def amount_donated(self):
return 99800
