class ProductItemReview(BaseModel):
__table_args__ = {'extend_existing': True}
__tablename__ = 'product_item_reviews'
id = db.Column(db.BigInt(unsigned=True), primary_key=True, autoincrement=True)
uuid = db.Column(db.String(32), unique=True)
product_item_id = db.Column(db.BigInt(unsigned=True), db.ForeignKey('product_items.id'))
product_id = db.Column(db.BigInt(unsigned=True), db.ForeignKey('products.id'))
site_id = db.Column(db.BigInt(unsigned=True), db.ForeignKey('sites.id'))
username = db.Column(db.String(255), nullable=True)
title = db.Column(db.Text, nullable=True)
attr = db.Column(db.String(255), nullable=True)
rating = db.Column(db.Integer, default=0)
color = db.Column(db.String(255), nullable=True)
size = db.Column(db.String(255), nullable=True)
helpers = db.Column(db.Integer, default=0)
detail_link = db.Column(db.String(255), default='')
content = db.Column(db.Text, default='')
is_processed = db.Column(db.Integer, default=1)
date = db.Column(db.Date, nullable=True)
created_at = db.Column(db.DateTime, default=func.now())
updated_at = db.Column(db.DateTime, default=func.now(), onupdate=func.now())
product_item = relationship('ProductItem', back_populates="product_item_reviews")
class ProductItem(BaseModel):
__table_args__ = {'extend_existing': True}
__tablename__ = "product_items"
id = db.Column(db.BigInt(unsigned=True), primary_key=True, autoincrement=True)
product_id = db.Column(db.BigInt(unsigned=True), db.ForeignKey('products.id'))
site_id = db.Column(db.BigInt(unsigned=True), db.ForeignKey('sites.id'))
rating = db.Column(db.Float, default=0.0)
reviews = db.Column(db.Integer, default=0)
rating_change = db.Column(db.Float, default=0.0)
reviews_change = db.Column(db.Integer, default=0)
price = db.Column(db.String(255), default='')
review_date = db.Column(db.Date, nullable=True)
available_date = db.Column(db.Date, nullable=True)
questions = db.Column(db.Integer, default=0)
answers = db.Column(db.Integer, default=0)
classify_rank = db.Column(db.JSON, nullable=True)
feature_rate = db.Column(db.JSON, nullable=True)
crawl_date = db.Column(db.Date, nullable=True)
shop_item_id = db.Column(db.BigInt(unsigned=True), db.ForeignKey('shop_items.id'))
img = db.Column(db.String(255), nullable=True)
created_at = db.Column(db.DateTime, default=func.now())
updated_at = db.Column(db.DateTime, default=func.now(), onupdate=func.now())
product = relationship('Product', back_populates="product_items")
site = relationship('Site', back_populates="product_items")
daily_ranks = relationship('ProductItemDailyRank', back_populates="product_item")
product_item_reviews = relationship('ProductItemReview', back_populates="product_item")
class ProductTypeProductRelation(BaseModel):
__table_args__ = {'extend_existing': True}
__tablename__ = 'product_type_product_relations'
product_id = db.Column(db.BigInt(unsigned=True), db.ForeignKey('products.id'), primary_key=True)
product_type_id = db.Column(db.BigInt(unsigned=True), db.ForeignKey('product_types.id'), primary_key=True)
product = relationship('Product', back_populates="product_type_relations")
product_type = relationship('ProductType', back_populates="product_relations")
class ProductItemDailyRank(BaseModel):
__table_args__ = {'extend_existing': True}
__tablename__ = 'product_item_daily_ranks'
id = db.Column(db.BigInt(unsigned=True), primary_key=True, autoincrement=True)
date = db.Column(db.Date, nullable=True)
product_item_id = db.Column(db.BigInt(unsigned=True), db.ForeignKey('product_items.id'))
classify_id = db.Column(db.BigInt(unsigned=True), db.ForeignKey('classifies.id'))
rank = db.Column(db.Integer, default=0)
created_at = db.Column(db.DateTime, default=func.now())
updated_at = db.Column(db.DateTime, default=func.now(), onupdate=func.now())
product_item = relationship('ProductItem', back_populates="daily_ranks")
class ShopItem(BaseModel):
__table_args__ = {'extend_existing': True}
__tablename__ = 'shop_items'
id = db.Column(db.BigInt(unsigned=True), primary_key=True, autoincrement=True)
shop_id = db.Column(db.BigInt(unsigned=True), db.ForeignKey('shops.id'))
site_id = db.Column(db.BigInt(unsigned=True), db.ForeignKey('sites.id'))
created_at = db.Column(db.DateTime, default=func.now())
updated_at = db.Column(db.DateTime, default=func.now(), onupdate=func.now())
shop = relationship('Shop', back_populates="shop_items")
site = relationship('Site', back_populates="shop_items")
class Tender(db.Model):
__tablename__ = 'tender'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
title = db.Column(db.String(20), nullable=False)
content = db.Column(db.String(100), nullable=False)
publish_date = db.Column(db.Date)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
city_id = db.Column(db.Integer, db.ForeignKey('city.id'))
users = db.relationship('User', backref=db.backref('tenders'))
def __init__(self, title, content, user_id, city_id, publish_date):
self.title = title
self.content = content
self.user_id = user_id
self.city_id = city_id
self.publish_date = publish_date
class Transaction(db.Model):
__tablename__ = 'transactions'
id = db.Column(db.Integer, primary_key=True)
user_requested_id = db.Column(db.Integer, db.ForeignKey('users.id'))
user_accepted = db.Column(db.String(256))
requested_quantity = db.Column(db.Integer)
accepted = db.Column(db.Boolean)
returned = db.Column(db.Boolean)
item = db.Column(db.String(256), db.ForeignKey('cars.name'))
date_requested = db.Column(db.DateTime)
date_accepted = db.Column(db.DateTime)
date_returned = db.Column(db.DateTime)
def __repr__(self):
return '<Transaction %r>' % self.id
class TaskRemarksHistory(db.Model, HistoryMixin):
__tablename__ = 'task_history'
id = db.Column(db.Integer, primary_key=True)
task_id = db.Column(db.Integer, db.ForeignKey('task.id'), nullable=False)
task = db.relationship('Task', backref='remarks')
task_creator = db.relationship('User', backref='tasks_created')
class SiteConfig(BaseModel):
__table_args__ = {'extend_existing': True}
__tablename__ = 'site_configs'
id = db.Column(db.BigInt(unsigned=True), primary_key=True, autoincrement=True)
site_id = db.Column(db.BigInt(unsigned=True), db.ForeignKey('sites.id'))
config = db.Column(db.JSON, nullable=True)
class Task(db.Model):
__tablename__ = 'task'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(200), nullable=False, unique=True)
description = db.Column(db.Text, nullable=False)
created_at = db.Column(db.DateTime,
server_default=func.now(),
nullable=False)
created_by = db.Column(db.Integer, db.ForeignKey('user.id'))
assigned_by = db.Column(db.Integer, db.ForeignKey('user.id'))
assigned_to = db.Column(db.Integer, db.ForeignKey('user.id'))
reviewed_by = db.Column(db.Integer, db.ForeignKey('user.id'))
created_by_id = db.relationship('User', foreign_keys=[created_by])
assigned_by_id = db.relationship('User', foreign_keys=[assigned_by])
assigned_to_id = db.relationship('User', foreign_keys=[assigned_to])
reviewed_by_id = db.relationship('User', foreign_keys=[reviewed_by])
status_id = db.Column(db.Integer, db.ForeignKey('status.id'))
status = db.relationship('Status', backref='tasks')
criticality_id = db.Column(db.Integer, db.ForeignKey('criticality.id'))
criticality = db.relationship('Criticality', backref='tasks')
expected_completion_date = db.Column(
db.DateTime,
server_default=Computed(sqltext=text('created_at + INTERVAL 3 DAY'),
persisted=True),
nullable=False)
project_id = db.Column(db.Integer, db.ForeignKey('project.id'))
project = db.relationship('Project', backref='tasks')
actual_completion_date = db.Column(db.DateTime,
server_default=null(),
nullable=True)
class ProjectRemarksHistory(db.Model, HistoryMixin):
__tablename__ = 'project_history'
id = db.Column(db.Integer, primary_key=True)
project_id = db.Column(db.Integer,
db.ForeignKey('project.id'),
nullable=False)
project = db.relationship('Project', backref='remarks')
user = db.relationship('User', backref='project_remarks')
class ProductItemDailyData(BaseModel):
__table_args__ = {'extend_existing': True}
__tablename__ = 'product_item_daily_data'
id = db.Column(db.BigInt(unsigned=True), primary_key=True, autoincrement=True)
date = db.Column(db.Date)
product_item_id = db.Column(db.BigInt(unsigned=True), db.ForeignKey('product_items.id'))
product_id = db.Column(db.BigInt(unsigned=True), db.ForeignKey('products.id'))
rating = db.Column(db.Float, default=0.0)
reviews = db.Column(db.Integer, default=0)
helpers = db.Column(db.Integer, default=0)
price = db.Column(db.String(255), default='')
questions = db.Column(db.Integer, default=0)
answers = db.Column(db.Integer, default=0)
classify_rank = db.Column(db.JSON, nullable=True)
feature_rate = db.Column(db.JSON, nullable=True)
created_at = db.Column(db.DateTime, default=func.now())
updated_at = db.Column(db.DateTime, default=func.now(), onupdate=func.now())
class ProductItemCrawlDate(BaseModel):
__table_args__ = {'extend_existing': True}
__tablename__ = "product_item_crawl_dates"
id = db.Column(db.BigInt(unsigned=True), primary_key=True, autoincrement=True)
product_item_id = db.Column(db.BigInt(unsigned=True), db.ForeignKey('product_items.id'))
classify_crawl_date = db.Column(db.Date, nullable=True)
created_at = db.Column(db.DateTime, default=func.now())
updated_at = db.Column(db.DateTime, default=func.now(), onupdate=func.now())
class StarboardEntry(db.Table, table_name='starboard_entries'):
id = db.Column(db.Serial, primary_key=True)
bot_message_id = db.Column(db.BigInt, nullable=True)
message_id = db.Column(db.BigInt, unique=True)
channel_id = db.Column(db.BigInt)
author_id = db.Column(db.BigInt)
guild_id = db.ForeignKey(Starboard.id, type=db.BigInt)
# There is some fuckery with ForeignKeys that I don't want to fix rn. They must be referenced as strings.
starboard_entries_index = db.Index(bot_message_id, message_id, 'guild_id')
class Blacklist(db.Model):
__tablename__ = 'blacklist'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
blacklisted_token = db.Column(db.String(256))
blacklisted_at = db.Column(db.DateTime)
def __repr__(self):
return '<Blacklisted Token %r>' % self.blacklisted_token
class Project(db.Model):
__tablename__ = 'project'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), nullable=False, unique=True)
description = db.Column(db.String(255), nullable=False, server_default='')
status_id = db.Column(db.Integer, db.ForeignKey('status.id'))
status = db.relationship('Status', backref='projects')
created_at = db.Column(db.DateTime,
server_default=func.now(),
nullable=False)
organisation_id = db.Column(db.Integer, db.ForeignKey('organisation.id'))
organisation = db.relationship('Organisation', backref='projects')
created_by = db.Column(db.Integer,
db.ForeignKey('user.id'),
nullable=False)
project_creator = db.relationship('User', backref='projects_created_by')
project_users = db.relationship('User',
backref='user_projects',
secondary='user_project')
class CategoryService(db.Model):
"""Categories to Services"""
__tablename__ = 'categories_services'
category_id = db.Column(db.Integer, db.ForeignKey(
"categories.id", ondelete="CASCADE"), primary_key=True)
service_id = db.Column(db.Integer, db.ForeignKey(
"services.id", ondelete="CASCADE"), primary_key=True)
def __repr__(self):
"""Representation of this class"""
e = self
return f"<CategoryService category_id={e.category_id} service_id={e.service_id}>"
def serialize(self):
"""Serialize a CategoryService SQLAlchemy obj to dictionary."""
return {
"category_id": self.category_id,
"service_id": self.service_id
}
class Item(db.Model):
__tablename__ = 'items'
name = db.Column(db.String(256), primary_key=True)
created_by = db.Column(db.String(256), db.ForeignKey('admins.email'))
date_in = db.Column(db.DateTime)
date_out = db.Column(db.DateTime)
quantity = db.Column(db.Integer)
transactions = db.relationship("Transaction", backref="items", lazy=True)
def __repr__(self):
return '<Item %r>' % self.name
class Article(db.Model):
__tablname__ = "article"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
title = db.Column(db.String(50), nullable=False)
desc = db.Column(db.Text, nullable=False)
content = db.Column(db.Text, nullable=False)
publish_time = db.Column(db.Date,
default=datetime.now,
onupdate=datetime.now)
author_id = db.Column(db.Integer,
db.ForeignKey("author.id"),
nullable=False)
category_id = db.Column(db.Integer,
db.ForeignKey("category.id"),
nullable=False)
create_time = db.Column(db.DateTime, default=datetime.now)
update_time = db.Column(db.DateTime,
default=datetime.now,
onupdate=datetime.now)
def __str__(self):
return "%s" % self.title
class User(db.Model):
"""User Model"""
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(30), nullable=False)
last_name = db.Column(db.String(30), nullable=False)
email = db.Column(db.String(200), nullable=False, unique=True)
password = db.Column(db.Text, nullable=False)
is_verified = db.Column(db.Boolean, server_default=text('0'))
created_at = db.Column(db.DateTime, server_default=func.now())
role_id = db.Column(db.Integer, db.ForeignKey('role.id'), nullable=False)
role = db.relationship('Role', backref='users')
class Inhouse(db.Model):
__tablename__ = "inhouse"
id = db.Column(db.Integer, primary_key=True)
application_id = db.Column(db.Integer, db.ForeignKey('applications.id'))
job_id = db.Column(db.String(256))
def __repr__(self):
return '<Inhouse Application %r>' % self.id
def to_dict(self):
return {
c.key: getattr(self, c.key)
for c in inspect(self).mapper.column_attrs
}
class InterviewQuestion(db.Model):
__tablename__ = "interviewquestions"
id = db.Column(db.Integer, primary_key=True)
application_id = db.Column(db.Integer, db.ForeignKey('applications.id'))
title = db.Column(db.String(256))
question = db.Column(db.String(256))
def __repr__(self):
return '<Interview Question %r' % self.Question
def to_dict(self):
return {
c.key: getattr(self, c.key)
for c in inspect(self).mapper.column_attrs
}
class FeaturedArticle(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
article_id = db.Column(db.Integer,
db.ForeignKey("article.id"),
nullable=False)
article_title = db.relationship("Article",
backref="featured",
uselist=False)
create_time = db.Column(db.DateTime, default=datetime.now)
update_time = db.Column(db.DateTime,
default=datetime.now,
onupdate=datetime.now)
def __str__(self):
return "%s" % self.id
class City(db.Model):
__tablename__ = 'city'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
city_name = db.Column(db.String(10), nullable=False)
province_id = db.Column(db.Integer, db.ForeignKey('province.id'))
def __init__(self, city_name, province_id):
self.city_name = city_name
self.province_id = province_id
@staticmethod
def generate_dict(city):
city_dict = {}
city_dict['city_id'] = city.id
city_dict['cityName'] = city.city_name
return city_dict
class ShopItemDetail(BaseModel):
__table_args__ = {'extend_existing': True}
__tablename__ = 'shop_item_details'
id = db.Column(db.BigInt(unsigned=True), primary_key=True, autoincrement=True)
shop_item_id = db.Column(db.BigInt(unsigned=True), db.ForeignKey('shop_items.id'))
little_goods_trend = db.Column(db.JSON, nullable=True)
high_rate_goods_trend = db.Column(db.JSON, nullable=True)
review_trend = db.Column(db.JSON, nullable=True)
rate_trend = db.Column(db.JSON, nullable=True)
little_goods_num = db.Column(db.Integer, default=0)
high_rate_goods_num = db.Column(db.Integer, default=0)
review_num = db.Column(db.Integer, default=0)
rate = db.Column(db.Integer, default=0)
created_at = db.Column(db.DateTime, default=func.now())
updated_at = db.Column(db.DateTime, default=func.now(), onupdate=func.now())
class External(db.Model):
__tablename__ = "external"
id = db.Column(db.Integer, primary_key=True)
application_id = db.Column(db.Integer, db.ForeignKey('applications.id'))
url = db.Column(db.String(256))
position = db.Column(db.String(256))
company = db.Column(db.String(256))
date_posted = db.Column(db.String(256))
deadline = db.Column(db.String(256))
def __repr__(self):
return '<External Application %r>' % self.id
def to_dict(self):
return {
c.key: getattr(self, c.key)
for c in inspect(self).mapper.column_attrs
}
class Organisation(db.Model):
__tablename__ = 'organisation'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(70), nullable=False, unique=True)
passcode = db.Column(db.Text, nullable=False)
location = db.Column(db.String(30), nullable=False)
registered_at = db.Column(db.DateTime,
server_default=func.now(),
nullable=False)
registered_by = db.Column(db.Integer,
db.ForeignKey('user.id'),
nullable=False)
organisation_registerer = db.relationship(
'User', backref='organisation_registered', uselist=False)
user_organisation = db.relationship('User',
backref='users',
secondary='user_organisation')
class TagLookup(db.Table, table_name="tag_lookup"):
id = db.PrimaryKeyColumn()
# we will create more indexes manually
name = db.Column(db.String, index=True)
location_id = db.Column(db.Integer(big=True), index=True)
owner_id = db.Column(db.Integer(big=True))
created_at = db.Column(db.Datetime, default="now() at time zone 'utc'")
tag_id = db.Column(db.ForeignKey("tags", "id"))
@classmethod
def create_table(cls, *, exists_ok=True):
statement = super().create_table(exists_ok=exists_ok)
# create the indexes
sql = (
"CREATE INDEX IF NOT EXISTS tag_lookup_name_trgm_idx ON tag_lookup USING GIN (name gin_trgm_ops);\n"
"CREATE INDEX IF NOT EXISTS tag_lookup_name_lower_idx ON tag_lookup (LOWER(name));\n"
"CREATE UNIQUE INDEX IF NOT EXISTS tag_lookup_uniq_idx ON tag_lookup (LOWER(name), location_id);"
)
return statement + "\n" + sql
class ModLogTargets(db.Table, table_name='modlog_targets'):
id = db.Column(db.Serial, primary_key=True)
entry_id = db.ForeignKey(ModLogEntry.id)
user_id = db.Column(db.BigInt, nullable=True)
mod_id = db.Column(db.BigInt, nullable=True)
class CartItem(db.Model):
__tablename__ = "cartitems"
id = db.Column(db.Integer, primary_key=True)
product_id = db.Column(db.Integer, db.ForeignKey('products.id'))
cart_id = db.Column(db.Integer, db.ForeignKey('carts.id'))
quantity = db.Column(db.Integer)
