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 TwitchClipTable(db.Table):
""" Creates the Clip table for storing clip following data. """
id = db.PrimaryKeyColumn()
guild_id = db.Column(db.Integer(big=True))
channel_id = db.Column(db.Integer(big=True))
broadcaster_id = db.Column(db.String())
last_25_clips = db.Column(db.Array(db.String()))
class Reports(db.Model):
__tablename__ = "reports"
id = db.Column(db.Integer, primary_key=True)
student = db.Column(db.String(4096))
discipline = db.Column(db.String(4096))
mark = db.Column(db.Float(asdecimal=False))
date = db.Column(db.Date)
class SnipeDeleteTable(db.Table, table_name="snipe_deletes"):
id = db.PrimaryKeyColumn()
user_id = db.Column(db.Integer(big=True))
guild_id = db.Column(db.Integer(big=True))
channel_id = db.Column(db.Integer(big=True))
message_id = db.Column(db.Integer(big=True))
message_content = db.Column(db.String())
attachment_urls = db.Column(db.Array(db.String()), nullable=True)
delete_time = db.Column(db.Integer(big=True))
class User(db.Model,UserMixin):
__tablname__ = 'user'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(20), doc='账户', nullable=False)
password = db.Column(db.String(32), doc='密码', nullable=False)
isAdmin = db.Column(db.Boolean, doc='是否管理员', default=False)
create_time = db.Column(db.DateTime, default=datetime.now, nullable=False)
update_time = db.Column(db.DateTime, default=datetime.now, onupdate=datetime.now)
def __str__(self):
return "%s" % self.account
class SnipeEditTable(db.Table, table_name="snipe_edits"):
id = db.PrimaryKeyColumn()
user_id = db.Column(db.Integer(big=True))
guild_id = db.Column(db.Integer(big=True))
channel_id = db.Column(db.Integer(big=True))
message_id = db.Column(db.Integer(big=True))
before_content = db.Column(db.String())
after_content = db.Column(db.String())
edited_time = db.Column(db.Integer(big=True))
jump_url = db.Column(db.String)
class Admin(db.Model):
__tablename__ = 'admins'
email = db.Column(db.String(256), primary_key=True)
name = db.Column(db.String(256))
date_created = db.Column(db.DateTime)
items = db.relationship("Item", backref="admins", lazy=True)
def __repr__(self):
return '<Admin %r>' % self.name
class Shop(BaseModel):
__table_args__ = {'extend_existing': True}
__tablename__ = 'shops'
id = db.Column(db.BigInt(unsigned=True), primary_key=True, autoincrement=True)
asin = db.Column(db.String(255))
name = 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())
shop_items = relationship('ShopItem', back_populates="shop")
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(256))
email = db.Column(db.String(256))
password = db.Column(db.String(256), nullable=False)
date_created = db.Column(db.DateTime)
admin = db.Column(db.Boolean)
transactions = db.relationship("Transaction", backref="users", lazy=True)
blacklist = db.relationship("Blacklist", backref="users", lazy=True)
def __repr__(self):
return '<User %r>' % self.name
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 Weibo(db.Model):
id = db.Column(db.Integer, primary_key=True)
content = db.Column(db.Text)
author = db.Column(db.String(64))
source = db.Column(db.String(64))
create_time = db.Column(db.DateTime, default='CURRENT_TIMESTAMP')
def __init__(self, content, author, source):
self.content = content
self.author = author
self.source = source
def __repr__(self):
return '<Weibo %r:%r>' % (self.author, self.content)
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 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 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 Site(BaseModel):
__table_args__ = {'extend_existing': True}
__tablename__ = 'sites'
id = db.Column(db.BigInt(unsigned=True), primary_key=True, autoincrement=True)
name = db.Column(db.String(255), default='')
short_name = db.Column(db.String(255), default='')
domain = db.Column(db.String(255), default='')
status = db.Column(db.String(3), default='On') # On Off
created_at = db.Column(db.DateTime, default=func.now())
updated_at = db.Column(db.DateTime, default=func.now(), onupdate=func.now())
# 一对多关系 目标类中必须要存在product属性
product_items = relationship('ProductItem', back_populates="site")
shop_items = relationship('ShopItem', back_populates="site")
site_config = relationship('SiteConfig', backref="site", uselist=False)
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 Allergies(db.Model):
__tablename__ = 'allergies'
id = db.Column(db.Integer, primary_key=True)
allergen = db.Column(db.String(255))
key_words = db.Column(ScalarListType())
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 Category(db.Model):
"""Categories"""
__tablename__ = 'categories'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(100), nullable=False)
is_active = db.Column(db.Boolean, nullable=False, server_default="true")
categories_services = db.relationship(
"CategoryService", backref="category", cascade="all, delete, delete-orphan", passive_deletes=True)
services = db.relationship(
"Service", secondary="categories_services", backref="categories")
def __repr__(self):
"""Representation of this class"""
e = self
return f"<Category id={e.id} name={e.name}>"
def serialize(self):
"""Serialize a Category SQLAlchemy obj to dictionary."""
return {
"id": self.id,
"name": self.name,
"is_active": self.is_active
}
class ProductItemKeyword(BaseModel):
__table_args__ = {'extend_existing': True}
__tablename__ = 'product_item_keywords'
id = db.Column(db.BigInt(unsigned=True), primary_key=True, autoincrement=True)
name = db.Column(db.String(255))
created_at = db.Column(db.DateTime, default=func.now())
updated_at = db.Column(db.DateTime, default=func.now(), onupdate=func.now())
class Classify(BaseModel):
__table_args__ = {'extend_existing': True}
__tablename__ = 'classifies'
id = db.Column(db.BigInt(unsigned=True), primary_key=True, autoincrement=True)
name = db.Column(db.String(255), nullable=False)
created_at = db.Column(db.DateTime, default=func.now())
updated_at = db.Column(db.DateTime, default=func.now(), onupdate=func.now())
class User(db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(10), nullable=False)
password = db.Column(db.String(100), nullable=False)
telephone = db.Column(db.String(11), nullable=False)
def __init__(self, username, password, telephone):
self.username = username
self.telephone = telephone
self.password = generate_password_hash(password=password)
def check_password(self, raw_password):
result = check_password_hash(self.password, raw_password)
return result
def __repr__(self):
return str(self.id)
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 TwitchTable(db.Table):
""" Create the twitch database table. """
id = db.PrimaryKeyColumn()
guild_id = db.Column(db.Integer(big=True))
channel_id = db.Column(db.Integer(big=True))
streamer_name = db.Column(db.String)
streamer_last_game = db.Column(db.String())
streamer_last_datetime = db.Column(db.Datetime())
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(20))
username = db.Column(db.String(20))
password_hash = db.Column(db.String(128))
def set_password(self, password):
self.password_hash = generate_password_hash(password)
def validate_password(self, password):
return check_password_hash(self.password_hash, password)
def is_active(self):
return True
def get_id(self):
return self.id
def is_authenticated(self):
return True
class ModLogEntry(db.Table, table_name='modlog'):
id = db.Column(db.Serial, primary_key=True)
channel_id = db.Column(db.BigInt)
message_id = db.Column(db.BigInt)
guild_id = db.Column(db.BigInt)
action = db.Column(db.String(length=16))
mod_id = db.Column(db.BigInt)
reason = db.Column(db.Text)
extra = db.Column(db.Text)
modlog_guild_id_index = db.Index(guild_id)
class Product(db.Model):
__tablename__ = 'products'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(256), index=True, unique=True)
price = db.Column(db.Float)
inventory_count = db.Column(db.Integer)
cartitems = db.relationship("CartItem", backref="products", lazy=True)
def __repr__(self):
return '<Product %r>' % self.title
class ProductType(BaseModel):
__table_args__ = {'extend_existing': True}
__tablename__ = 'product_types'
id = db.Column(db.BigInt(unsigned=True), primary_key=True, autoincrement=True)
name = db.Column(db.String(255))
product_relations = relationship("ProductTypeProductRelation", back_populates="product_type")
created_at = db.Column(db.DateTime, default=func.now())
updated_at = db.Column(db.DateTime, default=func.now(), onupdate=func.now())
class ClassifyCrawlProgress(BaseModel):
__table_args__ = {'extend_existing': True}
__tablename__ = "classify_crawl_progresses"
id = db.Column(db.BigInt(unsigned=True), primary_key=True, autoincrement=True)
model_id = db.Column(db.BigInt(unsigned=True), nullable=False)
model = db.Column(db.String(255), nullable=False)
total = db.Column(db.Integer, default=0)
finished = 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())
