class Addproduct(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80), nullable=False)
price = db.Column(db.Numeric(10, 2), nullable=False)
discount = db.Column(db.Integer, default=0)
colors = db.Column(db.Text(20), nullable=False, default='none')
desc = db.Column(db.Text(200), nullable=False)
model = db.Column(db.String(80), nullable=False)
watt = db.Column(db.Integer, nullable=False, default=0)
cutout = db.Column(db.String(80), nullable=False, default="XX*XX")
outer = db.Column(db.String(80), nullable=False, default="00*00")
height = db.Column(db.String(80), nullable=False, default=1)
stock = db.Column(db.Integer, nullable=False, default="Yes")
pub_date = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
category_id = db.Column(db.Integer,
db.ForeignKey('category.id'),
nullable=False)
category = db.relationship('Category',
backref=db.backref('categories', lazy=True))
image_1 = db.Column(db.String(150), nullable=False, default='image.jpg')
image_2 = db.Column(db.String(150), nullable=False, default='image.jpg')
image_3 = db.Column(db.String(150), nullable=False, default='image.jpg')
def __repr__(self):
return '<Addproduct %r>' % self.name
class Salt(BaseMixin, db.Model, ReprMixin):
name = db.Column(db.String(127), nullable=False, index=True)
prescription_required = db.Column(db.Boolean(), default=True)
usage = db.Column(db.Text(), nullable=True)
working = db.Column(db.Text(), nullable=True)
side_effects = db.Column(db.Text(), nullable=True)
store_id = db.Column(db.ForeignKey('store.id', ondelete='CASCADE'), index=True, nullable=False)
products = db.relationship('Product', back_populates='salts', secondary='product_salt')
store = db.relationship('Store', foreign_keys=[store_id], uselist=False)
UniqueConstraint(name, store_id)
class CheckInAnswer(db.Model):
id = db.Column(db.Integer, primary_key=True)
check_in_question_id = db.Column(db.Integer,
db.ForeignKey('check_in_question.id'),
index=True,
nullable=False)
check_in_question = db.relationship('CheckInQuestion',
backref='check_in_answers')
user_id = db.Column(db.Integer,
db.ForeignKey('user.id'),
index=True,
nullable=False)
user = db.relationship('User', backref='check_in_answers')
text = db.Column(db.Text(), nullable=False)
is_destroyed = db.Column(db.Boolean(), default=False)
created_at = db.Column(db.DateTime, default=datetime.datetime.utcnow)
def __init__(self,
user,
text,
check_in_question=None,
check_in_question_id=None):
if check_in_question_id:
self.check_in_question_id = check_in_question_id
else:
self.check_in_question = check_in_question
self.user = user
self.text = text
def __repr__(self):
return '<CheckInAnswer id={}, check_in_question_id={}, user_id={}, is_destroyed={}, created_at={}>'.format(
self.id, self.check_in_question_id, self.user_id,
self.is_destroyed, self.created_at)
class Tweet(SearchableMixin, db.Model):
__searchable__ = ['textbody']
id = db.Column(db.Integer, primary_key=True)
identifier = db.Column(db.String(32), nullable=False)
textbody_source = db.Column(db.String(500), nullable=False)
textbody_markdown = db.Column(db.Text(), nullable=False)
userid = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
comments = db.relationship('Comment', backref='tweet', lazy="dynamic")
created_utc = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
edited_utc = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
stickied = db.Column(db.Boolean, default=False)
is_banned = db.Column(db.Boolean, default=False)
is_nsfw = db.Column(db.Boolean, default=False)
is_edited = db.Column(db.Boolean, default=False)
comment_path_counter = db.Column(db.Integer, default=1, autoincrement=True)
likes = db.relationship('Like', backref='tweet', lazy='dynamic')
@classmethod
def get_identifier(cls):
while True:
ident = secrets.token_hex(nbytes=16)
if not cls.query.filter_by(identifier=ident).first():
return ident
def __repr__(self):
return '<Tweet {}>'.format(self.id)
class Rider(BaseMixin, ReprMixin, UserMixin, db.Model):
__repr_fields__ = ['id', 'first_name']
email = db.Column(db.String(127), unique=True, nullable=True, index=True)
password = db.Column(db.String(255), nullable=True)
first_name = db.Column(db.String(55), nullable=False)
last_name = db.Column(db.String(55), nullable=True)
mobile_number = db.Column(db.String(20),
unique=True,
nullable=False,
index=True)
company_name = db.Column(db.String(55), nullable=True)
counter = db.Column(db.Integer, nullable=True, default=0)
picture = db.Column(db.Text(), nullable=True, index=True)
active = db.Column(db.Boolean(), default=False)
confirmed_at = db.Column(db.DateTime(), default=datetime.utcnow)
last_login_at = db.Column(db.DateTime())
current_login_at = db.Column(db.DateTime())
last_login_ip = db.Column(db.String(45))
current_login_ip = db.Column(db.String(45))
login_count = db.Column(db.Integer)
device_limit = db.Column(db.Integer, nullable=True, default=0)
devices = db.relationship('Device',
back_populates='riders',
secondary='rider_device')
class Product(BaseMixin, db.Model, ReprMixin):
name = db.Column(db.String(127), unique=True, nullable=False, index=True)
description = db.Column(db.JSON(), nullable=True)
sub_description = db.Column(db.Text(), nullable=True)
is_disabled = db.Column(db.Boolean(), default=False)
url = db.Column(db.Text())
drug_schedule = db.Column(db.String(55))
drug_type = db.Column(db.String(55))
dosage = db.Column(db.String(55))
formulation_types = db.Column(db.String(55))
price = db.Column(NUMERIC(8, 2), default=0)
prescription_required = db.Column(db.Boolean(), default=False)
therapeutic_name = db.Column(db.String(255), nullable=True)
is_loose = db.Column(db.Boolean(), default=False)
barcode = db.Column(db.String(13), nullable=True, unique=True)
brand_id = db.Column(db.ForeignKey('brand.id'), index=True, nullable=False)
taxes = db.relationship('Tax', back_populates='products', secondary='product_tax')
tags = db.relationship('Tag', back_populates='products', secondary='product_tag')
brand = db.relationship('Brand', foreign_keys=[brand_id], uselist=False, back_populates='products')
stocks = db.relationship('Stock', uselist=True, cascade="all, delete-orphan", lazy='dynamic')
# distributors = db.relationship('Distributor', back_populates='products', secondary='product_distributor')
combos = db.relationship('Combo', back_populates='products', secondary='combo_product', lazy='dynamic')
salts = db.relationship('Salt', back_populates='products', secondary='product_salt', lazy='dynamic')
product_salts = db.relationship('ProductSalt', lazy='dynamic', back_populates='product')
@hybrid_property
def short_code(self):
return re.sub(r'[AEIOU ]', '', self.name, flags=re.IGNORECASE)[:5]
@hybrid_property
def brand_name(self):
return self.brand.name
@brand_name.expression
def brand_name(self):
return select([Brand.name]).where(Brand.id == self.brand_id).as_scalar()
class Comment(db.Model):
id = db.Column(db.Integer, primary_key=True)
comment = db.Column(db.Text(2000))
author = db.Column(db.String(150))
article = db.Column(db.ForeignKey('article.id'))
created_at = db.Column(db.DateTime(), default=datetime.utcnow)
def __repr__(self):
return f'{self.author}{self.comment}'
class Chat(db.Model, BaseMixin):
sender_id = db.Column(db.Integer, db.ForeignKey('user.id'))
receiver_id = db.Column(db.Integer, db.ForeignKey('user.id'))
message = db.Column(db.Text(), nullable=False, default='')
is_read = db.Column(db.Boolean(False))
read_on = db.Column(db.TIMESTAMP, default=None)
sender = db.relationship('User', lazy='subquery', foreign_keys=[sender_id])
receiver = db.relationship('User', lazy='subquery', foreign_keys=[receiver_id])
class Comment(db.Model):
id = db.Column(db.Integer, primary_key=True)
messages = db.Column(db.Text())
created_at = db.Column(db.DateTime, default=datetime.utcnow())
edited_at = db.Column(db.DateTime)
user_id = db.Column(db.Integer, db.ForeignKey("user.id"))
answer_id = db.Column(db.Integer, db.ForeignKey("answer.id"))
flags = db.relationship("CommentFlag", backref="comment", lazy="dynamic")
def __repr__(self):
return "Comment {}".format(self.id)
class Course(db.Model):
"""
This class defines the course table
"""
__tablename__ = "course"
cid = db.Column(db.Integer, primary_key=True, nullable=False, unique=True)
name = db.Column(db.String(256), nullable=False)
description = db.Column(db.Text(), nullable=True)
instructor = db.Column(db.String(256), nullable=False)
position = db.Column(db.Integer)
quality = db.relationship("Quality", backref="course", lazy=True)
difficulties = db.relationship("Difficulty", backref="course", lazy=True)
time_spent = db.relationship("TimeSpent", backref="course", lazy=True)
prereqs = db.relationship("Prereq", backref="course", lazy=True)
def __init__(self, cid, name, instructor, position, description=""):
self.cid = cid
self.description = description
self.instructor = instructor
self.name = name
self.position = position
def update(self, name, instructor, position, description):
self.name = name
self.instructor = instructor
self.description = description
self.position = position
self.save()
def save(self):
"""
Save course to database
:return:
"""
db.session.add(self)
db.session.commit()
def delete(self):
"""
Delete a course from db
:return:
"""
relationships = [
self.prereqs, self.quality, self.difficulties, self.time_spent
]
for rel in relationships:
for i in rel:
i.delete()
db.session.delete(self)
db.session.commit()
class Store(db.Model):
__tablename__ = "stores"
id = db.Column(db.Integer, primary_key=True, nullable=False)
name = db.Column(db.Text(), nullable=False)
postcode = db.Column(db.Text(), nullable=False)
longitude = db.Column(db.Float)
latitude = db.Column(db.Float)
geo = db.Column(Geometry(geometry_type="POINT"))
__table_args__ = (db.UniqueConstraint('name',
'postcode',
name='_name_postcode_uc'), )
def __repr__(self):
return "<City {name} ({lat}, {lon})>".format(name=self.name,
lat=self.latitude,
lon=self.longitude)
def update_geometry(self):
point = 'POINT({} {})'.format(self.longitude, self.latitude)
self.geo = point
class Question(db.Model, BaseMixin):
question = db.Column(db.Text(), nullable=False)
question_type = db.Column(db.Integer,
db.ForeignKey('question_type.id'),
nullable=False)
task_id = db.Column(db.Integer, db.ForeignKey('task.id'), nullable=False)
task = db.relationship('Task', backref='questions')
@hybrid_property
def choices(self):
return self.task.choices
class Question(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(255))
messages = db.Column(db.Text())
created_at = db.Column(db.DateTime, default=datetime.utcnow())
edited_at = db.Column(db.DateTime)
user_id = db.Column(db.Integer, db.ForeignKey("user.id"))
is_solved = db.Column(db.Boolean, default=False)
answers = db.relationship("Answer", backref="question", lazy="dynamic")
flags = db.relationship("QuestionFlag", backref="question", lazy="dynamic")
votes = db.relationship("QuestionVote", backref="question", lazy="dynamic")
def __repr__(self):
return "Question {}".format(self.title)
class UserProfile(BaseMixin, db.Model):
first_name = db.Column(db.String(255))
last_name = db.Column(db.String(255))
gender = db.Column(db.Enum('male', 'female', 'na', name='gender'),
default='na')
dob = db.Column(db.DateTime,
default=db.func.current_timestamp(),
nullable=True)
profile_picture = db.Column(db.Text(), nullable=True)
user_id = db.Column(db.Integer,
db.ForeignKey('user.id', ondelete='CASCADE'),
unique=True)
user = db.relationship('User',
back_populates="user_profile",
single_parent=True)
class User(BaseMixin, ReprMixin, UserMixin, db.Model):
__repr_fields__ = ['id', 'name']
razor_pay_id = db.Column(db.String(20), nullable=True, unique=True)
email = db.Column(db.String(127), unique=True, nullable=True, index=True)
password = db.Column(db.String(255), nullable=True)
first_name = db.Column(db.String(55), nullable=False)
last_name = db.Column(db.String(55), nullable=True)
mobile_number = db.Column(db.String(20),
unique=True,
nullable=False,
index=True)
business_name = db.Column(db.String(55), nullable=True)
picture = db.Column(db.Text(), nullable=True, index=True)
active = db.Column(db.Boolean())
confirmed_at = db.Column(db.DateTime())
last_login_at = db.Column(db.DateTime())
current_login_at = db.Column(db.DateTime())
last_login_ip = db.Column(db.String(45))
current_login_ip = db.Column(db.String(45))
login_count = db.Column(db.Integer)
roles = db.relationship('Role',
back_populates='users',
secondary='user_role')
@hybrid_property
def fixed_dues(self):
from src.dues.models import Due
return Due.query.with_entities(Due.amount)\
.filter(Due.is_paid.isnot(True), Due.creator_id == current_user.id, Due.is_cancelled.isnot(True),
Due.transaction_type == 'fixed',
Due.customer_id == self.id).limit(1).scalar()
@hybrid_property
def subscriptions(self):
from src.dues.models import Due
return Due.query.with_entities(func.count(Due.id)) \
.filter(Due.creator_id == current_user.id, Due.is_cancelled.isnot(True),
Due.transaction_type == 'subscription',
Due.customer_id == self.id).limit(1).scalar()
class Message(db.Model):
__tablename__ = "messages"
id = db.Column(db.Integer, primary_key=True)
body = db.Column(db.Text())
author_id = db.Column(db.Integer, db.ForeignKey("users.id"))
created_on = db.Column(db.DateTime, default=datetime.utcnow)
chat_id = db.Column(db.Integer, db.ForeignKey("chats.id"), nullable=False)
def __repr__(self):
return "<Message {}>".format(self.id)
@classmethod
def find_by_id(cls, id):
"""
Get a class instance given its id
:param id: int
:return: Class instance
"""
return cls.query.get(int(id))
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()
class CheckInQuestion(db.Model):
id = db.Column(db.Integer, primary_key=True)
check_in_id = db.Column(db.Integer,
db.ForeignKey('check_in.id'),
index=True,
nullable=False)
check_in = db.relationship('CheckIn', backref='check_in_questions')
text = db.Column(db.Text(), nullable=False)
order = db.Column(db.Integer)
is_destroyed = db.Column(db.Boolean(), default=False)
created_at = db.Column(db.DateTime, default=datetime.datetime.utcnow)
def __init__(self, check_in, text, order):
self.check_in = check_in
self.text = text
self.order = order
def __repr__(self):
return '<CheckInQuestion id={}, check_in_id={}, order={}, is_destroyed={}, created_at={}>'.format(
self.id, self.check_in_id, self.order, self.is_destroyed,
self.created_at)
class Tweet(db.Model):
__tablename__ = 'tweets'
id = db.Column(db.Integer, primary_key=True)
media_url = db.Column(db.String(200))
tweet_date = db.Column(db.DateTime(), nullable=False,
default=dt.datetime.utcnow)
twitter_id = db.Column(db.BigInteger, nullable=False, unique=True)
handle = db.Column(db.String(15), nullable=False, unique=True)
text = db.Column(db.Text(280), nullable=False)
profile_user = db.Column(db.String(35), nullable=False, unique=True)
name = db.Column(db.String(50), nullable=False)
tweet_link = db.Column(db.String(65), nullable=False)
timestamp = db.Column(db.DateTime,
nullable=False,
default=dt.datetime.utcnow)
_type = db.Column(db.String(15), nullable=False, default="tweet")
def __repr__(self):
return (f"{self.handle} posted, "
f"the {self.timestamp.strftime('%Y-%m-%d')} "
f"at {self.timestamp.strftime('%H:%M:%s')}, the following:\n"
f"{self.text}")
class Product(db.Model, BaseMixin, ReprMixin):
name = db.Column(db.String(55), unique=False, nullable=False)
min_stock = db.Column(db.SmallInteger, nullable=False)
auto_discount = db.Column(db.FLOAT(precision=2), default=0, nullable=False)
description = db.Column(db.JSON, nullable=True)
sub_description = db.Column(db.Text(), nullable=True)
is_disabled = db.Column(db.Boolean(), default=False)
retail_shop_id = db.Column(
db.Integer, db.ForeignKey('retail_shop.id', ondelete='CASCADE'))
distributor_id = db.Column(db.Integer, db.ForeignKey('distributor.id'))
brand_id = db.Column(db.Integer, db.ForeignKey('brand.id'))
retail_shop = db.relationship('RetailShop',
foreign_keys=[retail_shop_id],
uselist=False,
back_populates='products')
taxes = db.relationship('Tax',
back_populates='products',
secondary='product_tax')
tags = db.relationship('Tag',
back_populates='products',
secondary='product_tag')
brand = db.relationship('Brand',
foreign_keys=[brand_id],
uselist=False,
back_populates='products')
stocks = db.relationship('Stock',
uselist=True,
cascade="all, delete-orphan",
lazy='dynamic')
distributor = db.relationship('Distributor', back_populates='products')
combos = db.relationship('Combo',
back_populates='products',
secondary='combo_product')
salts = db.relationship('Salt',
back_populates='products',
secondary='product_salt')
add_ons = db.relationship('AddOn',
back_populates='products',
secondary='product_add_on')
@hybrid_property
def available_stock(self):
return self.stocks.filter(or_(Stock.is_sold == False, Stock.is_sold == None))\
.with_entities(func.Sum(Stock.units_purchased)-func.Sum(Stock.units_sold)).scalar()
@hybrid_property
def available_stocks(self):
return self.stocks.filter(
or_(Stock.is_sold == False, Stock.is_sold == None)).all()
@available_stock.expression
def available_stock(cls):
return select([func.Sum(Stock.units_purchased)-func.Sum(Stock.units_sold)])\
.where(and_(or_(Stock.is_sold == False, Stock.is_sold == None), Stock.product_id == cls.id)).as_scalar()
@hybrid_property
def mrp(self):
mrp = self.stocks.filter(or_(Stock.is_sold == False, Stock.is_sold == None))\
.with_entities(Stock.selling_amount).order_by(Stock.id).first()
return mrp[0] if mrp else 0
@hybrid_property
def similar_products(self):
if len(self.salts):
return [
i[0] for i in Product.query.with_entities(Product.id).join(
ProductSalt, and_(ProductSalt.product_id == Product.id)).
filter(ProductSalt.salt_id.in_(
[i.id for i in self.salts])).group_by(Product.id).having(
func.Count(func.Distinct(ProductSalt.salt_id)) == len(
self.salts)).all()
]
return []
class Entry(db.Model):
__tablename__ = 'user_info'
id = db.Column(db.Integer, primary_key=True)
user_name = db.Column(db.Text(), nullable=False)
password = db.Column(db.Text(), nullable=False)
class Answer(db.Model):
id = db.Column(db.Integer, primary_key=True)
messages = db.Column(db.Text())
class Product(BaseMixin, db.Model, ReprMixin):
name = db.Column(db.String(127), unique=False, nullable=False, index=True)
min_stock = db.Column(db.SmallInteger, nullable=False)
auto_discount = db.Column(db.FLOAT(precision=2), default=0, nullable=False)
description = db.Column(db.JSON(), nullable=True)
sub_description = db.Column(db.Text(), nullable=True)
is_disabled = db.Column(db.Boolean(), default=False)
default_quantity = db.Column(db.Float(precision=2), default=1)
quantity_label = db.Column(db.Enum('KG', 'GM', 'MG', 'L', 'ML', 'TAB', 'SYRUP', 'OTH', 'TAB', 'ML', 'CAP', 'INJ',
'BOTTLE', 'VAIL', 'KIT', 'STRIP', 'OTHER', 'PACK', 'SET', 'LTR', 'SACHET',
'PILLS', 'SYRINGE', 'SYRUP', 'ROLL', name='varchar'),
default='OTH', nullable=True)
is_loose = db.Column(db.Boolean(), default=False)
barcode = db.Column(db.String(13), nullable=True)
retail_shop_id = db.Column(UUID, db.ForeignKey('retail_shop.id', ondelete='CASCADE'), index=True, nullable=False)
brand_id = db.Column(UUID, db.ForeignKey('brand.id'), index=True, nullable=False)
retail_shop = db.relationship('RetailShop', foreign_keys=[retail_shop_id], uselist=False, back_populates='products')
taxes = db.relationship('Tax', back_populates='products', secondary='product_tax')
tags = db.relationship('Tag', back_populates='products', secondary='product_tag')
brand = db.relationship('Brand', foreign_keys=[brand_id], uselist=False, back_populates='products')
stocks = db.relationship('Stock', uselist=True, cascade="all, delete-orphan", lazy='dynamic')
# distributors = db.relationship('Distributor', back_populates='products', secondary='product_distributor')
combos = db.relationship('Combo', back_populates='products', secondary='combo_product')
salts = db.relationship('Salt', back_populates='products', secondary='product_salt')
add_ons = db.relationship('AddOn', back_populates='products', secondary='product_add_on')
UniqueConstraint('barcode', 'retail_shop_id', 'bar_retail_un')
@hybrid_property
def available_stock(self):
return self.stocks.filter(Stock.is_sold != True, Stock.expired == False)\
.with_entities(func.coalesce(func.Sum(Stock.units_purchased), 0)-func.coalesce(func.Sum(Stock.units_sold),
0)).scalar()
@hybrid_property
def available_stocks(self):
return self.stocks.filter(and_(or_(Stock.is_sold != True), Stock.expired == False)).all()
@available_stock.expression
def available_stock(cls):
return select([func.coalesce(func.Sum(Stock.units_purchased), 0)-func.coalesce(func.Sum(Stock.units_sold), 0)])\
.where(and_(or_(Stock.is_sold != True), Stock.product_id == cls.id)).as_scalar()
@hybrid_property
def mrp(self):
mrp = self.stocks.filter(or_(Stock.is_sold != True))\
.with_entities(Stock.selling_amount).order_by(Stock.id).first()
return mrp[0] if mrp else 0
@hybrid_property
def similar_products(self):
if len(self.salts):
return [i[0] for i in Product.query.with_entities(Product.id)
.join(ProductSalt, and_(ProductSalt.product_id == Product.id))
.filter(ProductSalt.salt_id.in_([i.id for i in self.salts])).group_by(Product.id)
.having(func.Count(func.Distinct(ProductSalt.salt_id)) == len(self.salts)).all()]
return []
@hybrid_property
def last_purchase_amount(self):
return self.stocks.order_by(desc(Stock.purchase_date)).first().purchase_amount
@hybrid_property
def last_selling_amount(self):
return self.stocks.order_by(desc(Stock.purchase_date)).first().selling_amount
@hybrid_property
def stock_required(self):
return abs(self.min_stock - self.available_stock)
@stock_required.expression
def stock_required(self):
return self.min_stock - self.available_stock
@hybrid_property
def is_short(self):
return self.min_stock >= self.available_stock
@hybrid_property
def product_name(self):
return self.name
@hybrid_property
def distributors(self):
return self.brand.distributors.all()
@hybrid_property
def brand_name(self):
return self.brand.name
@brand_name.expression
def brand_name(self):
return select([Brand.name]).where(Brand.id == self.brand_id).as_scalar()
class Question(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(255))
messages = db.Column(db.Text())
class BlogPost(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(50))
text = db.Column(db.Text())
author_id = db.Column(db.Integer, db.ForeignKey('user.id'))
class Temp_User(db.Model):
__tablename__ = "temp_user"
id = db.Column(db.Integer, primary_key=True)
user_name = db.Column(db.Text(), nullable=False)
auth_uuid = db.Column(db.Text(), nullable=False)
class Registered_User(db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
user_name = db.Column(db.Text(), nullable=False)
password = db.Column(db.Text(), nullable=False)
