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 Province(db.Model):
__tablename__ = 'province'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
province_name = db.Column(db.String(10), nullable=False)
city = db.relationship('City', backref='province', lazy='dynamic')
def __init__(self, province_name):
self.province_name = province_name
@staticmethod
def generateDict(province):
province_dict = {}
province_dict['province_id'] = province.id
province_dict['provinceName'] = province.province_name
return province_dict
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 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 CommandConfig(db.Table, table_name="command_config"):
""" Create db table for command config. """
id = db.PrimaryKeyColumn()
guild_id = db.Column(db.Integer(big=True), index=True)
channel_id = db.Column(db.Integer(big=True))
name = db.Column(db.String)
whitelist = db.Column(db.Boolean)
@classmethod
def create_table(cls, *, exists_ok=True):
statement = super().create_table(exists_ok=exists_ok)
# create the unique index
sql = "CREATE UNIQUE INDEX IF NOT EXISTS command_config_uniq_idx ON command_config (channel_id, name, whitelist);"
return statement + "\n" + sql
class StatisticsTable(db.Table, table_name="statistics"):
id = db.PrimaryKeyColumn()
message_deletes = db.Column(db.Integer(big=True))
bulk_message_deletes = db.Column(db.Integer(big=True))
message_edits = db.Column(db.Integer(big=True))
bans = db.Column(db.Integer(big=True))
unbans = db.Column(db.Integer(big=True))
channel_deletes = db.Column(db.Integer(big=True))
channel_creates = db.Column(db.Integer(big=True))
command_count = db.Column(db.Integer(big=True))
class User(db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String, nullable=False)
email = db.Column(db.String, nullable=False)
password = db.Column(db.String, nullable=False)
posts = relationship("BlogPost", backref="author")
def __init__(self, name, email, password):
self.name = name
self.email = email
#self.password = password
#self.password = bcrypt.generate_password_hash(password)
def __repr__(self):
return '<name {}'.format(self.name)
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 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 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 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 Commands(db.Table):
id = db.PrimaryKeyColumn()
guild_id = db.Column(db.Integer(big=True), index=True)
channel_id = db.Column(db.Integer(big=True))
author_id = db.Column(db.Integer(big=True), index=True)
used = db.Column(db.Datetime, index=True)
prefix = db.Column(db.String)
command = db.Column(db.String, index=True)
failed = db.Column(db.Boolean, index=True)
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 ModLogConfig(db.Table, table_name='modlog_config'):
guild_id = db.Column(db.BigInt, primary_key=True)
channel_id = db.Column(db.BigInt, default=0)
enabled = db.Column(db.Boolean, default=True)
log_auto = db.Column(db.Boolean, default=True)
dm_user = db.Column(db.Boolean, default=True)
poll_audit_log = db.Column(db.Boolean, default=True)
events = db.Column(db.Integer, default=_default_flags.value)
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):
"""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 WarnEntries(db.Table, table_name='warn_entries'):
id = db.Column(db.Serial, primary_key=True)
guild_id = db.Column(db.BigInt)
user_id = db.Column(db.BigInt)
mod_id = db.Column(db.BigInt)
reason = db.Column(db.Text)
warned_at = db.Column(db.Timestamp)
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())
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 TagTable(db.Table, table_name='tags'):
guild_id = db.Column(db.BigInt)
name = db.Column(db.Text)
content = db.Column(db.Text)
is_alias = db.Column(db.Boolean)
# meta data
created_at = db.Column(db.Timestamp, default="now() at time zone 'utc'")
created_by = db.Column(db.BigInt)
uses = db.Column(db.Integer, default=0)
tags_index = db.Index('LOWER(name)', guild_id)
__create_extra__ = ['PRIMARY KEY(name, guild_id)']
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 User(db.Model):
"""Class for user entity in database"""
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(64), unique=True, index=True, nullable=False)
username = db.Column(db.String(32),
nullable=False,
unique=True,
index=True)
_password = db.Column(db.String(128), nullable=False)
first_name = db.Column(db.String(32))
last_name = db.Column(db.String(32))
uuid = db.Column(db.String(36))
is_admin = db.Column(db.Boolean, default=False)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.uuid = str(uuid4())
self.password = kwargs['password']
def __str__(self):
return f"User {self.username}"
@hybrid_method
def verify_password(self, password: str) -> bool:
"""
Return true if password_hash and password are equals
"""
return check_password_hash(self._password, password)
@hybrid_property
def password(self) -> str:
"""Password getter"""
return self._password
@password.setter
def password(self, new_password: str):
"""Password setter that automatically generate hash"""
self._password = generate_password_hash(new_password)
def save(self):
"""Save entity to database"""
db.session.add(self)
db.session.commit()
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 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 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 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 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 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 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 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')
