class ContestantModel(db.Model):
id = db.Column(db.Integer, primary_key=True, nullable=False)
name = db.Column(db.String(16), nullable=False)
gender = db.Column(ENUM('male', 'female'), nullable=False)
birth = db.Column(db.Date, nullable=False)
agent_phone = db.Column(db.String(16), nullable=False)
phone = db.Column(db.String(16), nullable=True)
school = db.Column(db.String(64), nullable=True)
grade = db.Column(db.Integer, nullable=True)
klass = db.Column(db.Integer, nullable=True)
zip_code = db.Column(db.String(8), nullable=False)
address = db.Column(db.String(128), nullable=False)
detail_address = db.Column(db.String(128), nullable=False)
sector = db.Column(ENUM('programming', 'design', 'business'),
nullable=False)
photo = db.Column(db.String(64), nullable=True)
password = db.Column(db.String(256), nullable=False)
lunch_number = db.Column(db.Integer, nullable=False)
class Problems(Base):
__tablename__ = 'Problems'
problemIndex = Column(INTEGER(unsigned=True),
primary_key=True,
autoincrement=True,
nullable=False)
problemName = Column(VARCHAR(255), nullable=False, unique=True)
problemDifficulty = Column(ENUM(ENUMResources().const.BRONZE,
ENUMResources().const.SILVER,
ENUMResources().const.GOLD),
default=ENUMResources().const.BRONZE,
nullable=False)
solutionCheckType = Column(ENUM(ENUMResources().const.SOLUTION,
ENUMResources().const.CHECKER),
default=ENUMResources().const.CHECKER,
nullable=False)
numberOfTestCase = Column(INTEGER(unsigned=True),
default=0,
nullable=False)
limitedTime = Column(INTEGER(unsigned=True), default=3000,
nullable=False) #ms
limitedMemory = Column(INTEGER(unsigned=True),
default=1024,
nullable=False) #MB
problemPath = Column(TEXT, nullable=True)
isDeleted = Column(ENUM(ENUMResources().const.TRUE,
ENUMResources().const.FALSE),
default=ENUMResources().const.FALSE,
nullable=False)
class ArticlesOnBoard(Base):
__tablename__ = 'ArticlesOnBoard'
articleIndex = Column(INTEGER(unsigned=True),
primary_key=True,
autoincrement=True,
nullable=False)
articleType = Column(ENUM(ENUMResources().const.NOTICE,
ENUMResources().const.QUESTION,
ENUMResources().const.NORMAL),
default=ENUMResources().const.NORMAL,
nullable=False) # checker for notice
writerIdIndex = Column(INTEGER(unsigned=True),
ForeignKey(Members.memberIdIndex,
onupdate='CASCADE',
ondelete='CASCADE'),
nullable=False)
problemIndex = Column(INTEGER(unsigned=True),
ForeignKey(Problems.problemIndex,
onupdate='CASCADE',
ondelete='CASCADE'),
nullable=True)
title = Column(VARCHAR(1024), nullable=False)
content = Column(TEXT, nullable=False) # contents of article
viewCount = Column(INTEGER(unsigned=True), default=0, nullable=False)
replyCount = Column(INTEGER(unsigned=True), default=0, nullable=False)
sumOfLikeCount = Column(INTEGER(unsigned=True), default=0, nullable=False)
updateIp = Column(VARCHAR(20), nullable=False)
updateDate = Column(DATETIME, nullable=False)
isDeleted = Column(ENUM(ENUMResources().const.TRUE,
ENUMResources().const.FALSE),
default=ENUMResources().const.FALSE,
nullable=False)
class FeatureRequest(db.Model):
__tablename__ = 'feature_request'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(120), nullable=False)
description = db.Column(db.Text, nullable=False)
client = db.Column("client",
ENUM("Client A",
"Client B",
"Client C",
name="client_enum"),
nullable=False)
client_priority = db.Column(db.SmallInteger, nullable=False)
target_date = db.Column(db.Date, nullable=False)
product_area = db.Column("product_area",
ENUM('Policies',
'Billing',
'Claims',
'Reports',
name="product_area_enum"),
nullable=False)
created_at = db.Column(db.DateTime,
index=True,
default=datetime.datetime.utcnow)
updated_at = db.Column(db.DateTime,
index=True,
default=datetime.datetime.utcnow,
onupdate=datetime.datetime.utcnow)
def save(self, commit=True):
if commit:
instance = self
if not instance.id:
db.session.add(instance)
try:
db.session.commit()
except Exception as e:
print(e)
db.session.rollback()
return False
return True
return False
def add(self):
instance = self
is_exist = instance.query.filter_by(client=instance.client).filter_by(
client_priority=instance.client_priority).first()
if not is_exist:
return instance.save()
for record in instance.query.filter_by(client=instance.client):
record.client_priority += 1
record.save()
return instance.add()
class Current_Status(Base):
__tablename__ = 'current_status'
message_id = Column('message_id',
SMALLINT,
ForeignKey('status_message.id'),
primary_key=True)
component_id = Column('component_id', BINARY(16), primary_key=True)
component_type = Column('component_type',
ENUM('net', 'host', 'user', 'sensor', 'server',
'system'),
primary_key=False)
creation_time = Column('creation_time', TIMESTAMP, primary_key=False)
viewed = Column('viewed', ENUM('true', 'false'), primary_key=False)
supressed = Column('supressed', TINYINT, primary_key=False)
supressed_time = Column('supressed_time', TIMESTAMP, primary_key=False)
additional_info = Column('additional_info', TEXT, primary_key=False)
message = relationship(Status_Message, lazy=False)
# Sonar warning
@staticmethod
def _get_value_string(s):
return s if s is not None else ''
#
@staticmethod
def _get_value_uuid(s):
return str(uuid.UUID(bytes=s)) if s is not None else ''
@property
def serialize(self):
component_dict = self.host or self.net or self.sensor or self.user or self.system
if len(component_dict.keys()) > 0:
(component_name, component_ip) = component_dict.keys()[0]
else:
(component_name, component_ip) = (None, None)
# TODO: Fix relationship in BBDD. Added this to avoid crashing in
# apimethods.status
#component_name = ""
#component_ip = ""
message_level = self.message.level if self.message is not None else ""
message_description = self.message.desc if self.message is not None else ""
return {
'message_id': self.message_id,
'component_id': self._get_value_uuid(self.component_id),
'component_type': self.component_type,
'component_name': self._get_value_string(component_name),
'component_ip': self._get_value_string(component_ip),
'supressed_time': self.supressed_time,
'creation_time': self.creation_time,
'supressed': self.supressed,
'viewed': True if self.viewed != 'false' else False,
'level': message_level,
'description': message_description
}
class BackendCheck(Base):
__tablename__ = 'backend_check'
backend_name = Column(VARCHAR, ForeignKey('backend.name'), primary_key=True)
backend = relationship('Backend', backref=backref('backend_check', uselist=False))
ssl_hello_check = Column(TINYINT)
http_check = Column(TINYINT)
http_method = Column(ENUM('none','OPTIONS','HEAD','POST','GET'))
http_url = Column(VARCHAR)
http_check_expect = Column(ENUM('none','rstring','string','rstatus','status'))
http_check_expect_not = Column(TINYINT)
http_check_expect_value = Column(VARCHAR)
disable_on_404 = Column(TINYINT)
timeout_check = Column(VARCHAR)
class ExchangeProgres(db.Model):
__tablename__ = 'Exchange_Progress'
id = Column(BIGINT(12), primary_key=True)
book_no = Column(String(64, 'utf8mb4_bin'), nullable=False, comment='挂单编号')
user_id = Column(BIGINT(12), nullable=False, comment='用户id')
status = Column(ENUM('canceled', 'matched', 'sended', 'received',
'set_wallet', 'payed', 'disputed', 'complete'),
nullable=False,
comment='状态')
create_time = Column(INTEGER(11), nullable=False, comment='创建时间')
expire_time = Column(INTEGER(11), comment='过期时间')
extend_remark = Column(JSON, comment='备注')
entrust_type = Column(ENUM('maker', 'taker'))
class Backend(Base):
__tablename__ = 'backend'
name = Column(VARCHAR, primary_key=True)
balance_method = Column(ENUM('','source','first','static-rr','leastconn','roundrobin'))
mode = Column(ENUM('none','tcp','http'))
forwardfor = Column(TINYINT)
forwardfor_expect = Column(VARCHAR)
forwardfor_header = Column(VARCHAR)
cookie = Column(ENUM('none','prefix','rewrite','insert'))
cookie_name = Column(VARCHAR)
cookie_option_indirect = Column(TINYINT)
cookie_option_nocache = Column(TINYINT)
cookie_option_postonly = Column(TINYINT)
cookie_domain = Column(VARCHAR)
class Members(Base):
__tablename__ = 'Members'
memberIdIndex = Column(INTEGER(unsigned=True),
primary_key=True,
autoincrement=True,
nullable=False)
memberId = Column(VARCHAR(255), nullable=False, unique=True)
password = Column(VARCHAR(1024), nullable=False)
memberName = Column(VARCHAR(1024), nullable=False)
contactNumber = Column(VARCHAR(20), nullable=True)
emailAddress = Column(VARCHAR(1024), nullable=True)
detailInformation = Column(VARCHAR(1024), nullable=True)
authority = Column(SET(SETResources().const.ADMINISTRATOR,
SETResources().const.USER),
default=SETResources().const.USER,
nullable=False)
limitedUseDate = Column(DATETIME, default=None, nullable=True)
signedInDate = Column(DATETIME, nullable=False)
lastAccessDate = Column(DATETIME, nullable=True)
comment = Column(TEXT, nullable=True)
isDeleted = Column(ENUM(ENUMResources().const.TRUE,
ENUMResources().const.FALSE),
default=ENUMResources().const.FALSE,
nullable=False)
class WorkspaceInvitation(db.Model):
__tablename__ = 'WorkspaceInvitation'
winvitorid = db.Column(ForeignKey('WorkspaceMembership.uid'),
primary_key=True,
nullable=False)
wid = db.Column(ForeignKey('WorkspaceMembership.wid'),
primary_key=True,
nullable=False)
winviteeemail = db.Column(VARCHAR(50), primary_key=True, nullable=False)
winvitetime = db.Column(DateTime, nullable=False)
wstatus = db.Column(ENUM('accept', 'reject', 'pending'))
#invite_workspace = db.relationship('WorkspaceInvitation', backref='WorkspaceMembership',
# primaryjoin=(WorkspaceMembership.uid == winvitorid))
def __init__(self, winvitorid, wid, winviteeemail, winvitetime, wstatus):
self.winvitorid = winvitorid
self.wid = wid
self.winviteeemail = winviteeemail
self.winvitetime = winvitetime
self.wstatus = wstatus
def to_json(self):
json_comment = {
'winvitorid': self.winvitorid,
'wid': self.wid,
'winviteeemail': self.winviteeemail,
'winvitetime': self.winvitetime,
'wstatus': self.wstatus
}
return json_comment
class ChannelInvitation(db.Model):
__tablename__ = 'ChannelInvitation'
cinvitorid = db.Column(ForeignKey('ChannelMembership.uid'),
primary_key=True)
cid = db.Column(ForeignKey('ChannelMembership.cid'), primary_key=True)
cinviteeid = db.Column(ForeignKey('User.uid'), primary_key=True)
cinvitetime = db.Column(DateTime)
cstatus = db.Column(ENUM('accept', 'reject', 'pending'))
def __init__(self, cinvitorid, cid, cinviteeid, cinvitetime, cstatus):
self.cinvitorid = cinvitorid
self.cid = cid
self.cinviteeid = cinviteeid
self.cinvitetime = cinvitetime
self.cstatus = cstatus
def to_json(self):
json_comment = {
'cinvitorid': self.cinvitorid,
'cid': self.cid,
'cinviteeid': self.cinviteeid,
'cinvitetime': self.cinvitetime,
'cstatus': self.cstatus
}
return json_comment
class Channel(db.Model):
__tablename__ = 'Channel'
cid = db.Column(INTEGER(11), primary_key=True, autoincrement=True)
creatorid = db.Column(ForeignKey('WorkspaceMembership.uid'))
wid = db.Column(ForeignKey('WorkspaceMembership.wid'))
ctype = db.Column(ENUM('public', 'private', 'direct'))
cname = db.Column(VARCHAR(50), nullable=False)
ctime = db.Column(DateTime, nullable=False)
#create_channel = db.relationship('Channel', backref='WorkspaceMembership',
# primaryjoin=(creatorid==WorkspaceMembership.uid))
member_channel = db.relationship('ChannelMembership', backref='Channel')
def __init__(self, creatorid, wid, ctype, cname, ctime):
self.creatorid = creatorid
self.wid = wid
self.ctype = ctype
self.cname = cname
self.ctime = ctime
def to_json(self):
json_comment = {
'cid': self.cid,
'creatorid': self.creatorid,
'wid': self.wid,
'ctype': self.ctype,
'cname': self.cname,
'ctime': self.ctime
}
return json_comment
class DataOfMatch(Base):
__tablename__ = 'DataOfMatch'
dataOfMatchIndex = Column(INTEGER(unsigned=True),
primary_key=True,
autoincrement=True,
nullable=False)
problemIndex = Column(INTEGER(unsigned=True),
autoincrement=False,
nullable=False)
challengerIndex = Column(INTEGER(unsigned=True),
autoincrement=False,
nullable=False)
championIndex = Column(INTEGER(unsigned=True),
autoincrement=False,
nullable=False)
result = Column(
ENUM('win', 'lose', 'draw', '...ing...', 'server error'),
default='...ing...',
)
positionData = Column(TEXT, unique=False)
boardData = Column(TEXT, unique=False)
class Status_Message(Base):
__tablename__ = 'status_message'
id = Column('id', SMALLINT, primary_key=True)
level = Column('level',
ENUM('info', 'error', 'warning'),
primary_key=False)
content = Column('content', TEXT, primary_key=False)
desc = Column('description', TEXT, primary_key=False)
actions = relationship('Status_Action',
secondary=Status_Message_Action,
lazy='select')
@property
def serialize(self):
actions = [{
'content': x.content,
'link': x.link
} for x in self.actions]
return {
'msg_id': self.id,
'level': self.level,
'content': self.content,
'desc': self.desc,
'actions': actions
}
class User(Base):
__tablename__ = 'User'
userIndex = Column(INTEGER(unsigned=True),
primary_key=True,
autoincrement=True,
nullable=False)
userId = Column(VARCHAR(20),
nullable=False,
unique=True)
password = Column(CHAR(255),
nullable=False,
unique=False)
nickName = Column(VARCHAR(20),
nullable=False,
unique=True)
eMail = Column(VARCHAR(100),
nullable=False,
unique=False)
lastMatchDate = Column(DATETIME,
default=None,
nullable=True)
authority = Column(ENUM('admin', 'semiAdmin', 'user'),
nullable=False,
default='user')
class PostModel(db.Model, CommonMixin):
"""
失物招领 + 寻物启事 文章
"""
__tablename__ = 'posts'
id = db.Column(db.Integer, primary_key=True)
type = db.Column(ENUM('lost', 'found', 'people'), comment='文章类型')
user_id = db.Column(db.Integer,
db.ForeignKey('users.id'),
nullable=True,
comment='用户ID') # tourists also can post
contact = db.Column(db.String(20), comment='联系人')
title = db.Column(db.String(20), comment='标题')
phone = db.Column(db.String(20), comment='手机号')
content = db.Column(db.Text, comment='留言内容')
comment_ids = db.relationship('CommentModel', backref='post')
image = db.Column(db.String(256), comment='图片路径')
def asdict(self, columns=None):
if columns is None:
columns = [
'id', 'content', 'title', 'updated_time', 'type', 'contact',
'phone', 'image'
]
return super().asdict(columns)
class PackageFile(TableBase):
# 包文件id
pfile_id = sa.Column(INTEGER(unsigned=True),
nullable=False,
primary_key=True,
autoincrement=True)
# 安装包引用的resource_id, None则为外部地址
resource_id = sa.Column(INTEGER(unsigned=True), nullable=True)
# 安装包文件名
filename = sa.Column(VARCHAR(128), nullable=True)
package_id = sa.Column(sa.ForeignKey('packages.package_id',
ondelete="RESTRICT",
onupdate='RESTRICT'),
nullable=False)
# 包类型
ftype = sa.Column(VARCHAR(32), nullable=False)
# 安装包版本号
gversion = sa.Column(VARCHAR(64), nullable=False)
address = sa.Column(VARCHAR(200), nullable=True)
uptime = sa.Column(INTEGER(unsigned=True), nullable=False)
status = sa.Column(VARCHAR(16),
ENUM(*manager_common.DOWNFILESTATUS),
default=manager_common.DOWNFILE_FILEOK,
nullable=False)
desc = sa.Column(VARCHAR(256), nullable=True)
__table_args__ = (sa.UniqueConstraint('address', name='address_unique'),
sa.Index('ftype_index',
'ftype'), InnoDBTableBase.__table_args__)
class SocialMedia(Base, TableArgsMixin):
__tablename__ = "socialmedia"
id = Column(INTEGER(unsigned=True), primary_key=True, autoincrement=True)
type = Column(VARCHAR(128), nullable=False, server_default="")
site = Column(ENUM(*socialmedia_sites), nullable=False)
ref_id = Column(BIGINT(unsigned=True), nullable=False,
server_default=text("0"))
weibo_id = Column(VARCHAR(32), nullable=False,
server_default="")
weibo_name = Column(VARCHAR(64), nullable=True, server_default=None)
weibo_photo = Column(VARCHAR(64), nullable=False, server_default="")
weibo_tweets = Column(INTEGER(unsigned=True), nullable=False,
server_default=text("0"))
weibo_followers = Column(INTEGER(unsigned=True), nullable=False,
server_default=text("0"))
weibo_following = Column(INTEGER(unsigned=True), nullable=False,
server_default=text("0"))
weibo_brief = Column(VARCHAR(128), nullable=False, server_default="")
visible = Column(TINYINT, nullable=False,
server_default=text(VisibleValue.SHOWN))
created_at = Column(
TIMESTAMP, nullable=False,
server_default=text("CURRENT_TIMESTAMP")
)
updated_at = Column(
TIMESTAMP, nullable=False,
server_default=text("CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP")
)
Index("ix__type__ref_id", type, ref_id)
class RepliesOnBoard(Base):
__tablename__ = 'RepliesOnBoard'
boardReplyIndex = Column(INTEGER(unsigned=True),
primary_key=True,
autoincrement=True,
nullable=False)
articleIndex = Column(INTEGER(unsigned=True),
ForeignKey(ArticlesOnBoard.articleIndex,
onupdate='CASCADE',
ondelete='CASCADE'),
nullable=False)
boardReplierIdIndex = Column(INTEGER(unsigned=True),
ForeignKey(Members.memberIdIndex,
onupdate='CASCADE',
ondelete='CASCADE'),
nullable=False)
boardReplyContent = Column(TEXT, nullable=False)
sumOfLikeCount = Column(INTEGER(unsigned=True), default=0, nullable=False)
boardReplierIp = Column(VARCHAR(20), nullable=False)
boardRepliedDate = Column(DATETIME, nullable=False)
isDeleted = Column(ENUM(ENUMResources().const.TRUE,
ENUMResources().const.FALSE),
default=ENUMResources().const.FALSE,
nullable=False)
class Masteries(Base):
__tablename__ = 'Masteries'
id = Column(Integer, primary_key=True)
tree = Column(ENUM("Ferocity", "Resolve", "Cunning"), nullable=False)
ranks = Column(Integer, nullable=False)
image = Column(String(50), nullable=False)
translations = relationship("MasteriesTranslations", lazy="dynamic")
def toJson(self, id_locale, **kwargs):
data = {
"translation": self.get_translation(id_locale),
"tree": self.tree,
"ranks": self.ranks,
"image": self.image
}
for key, value in kwargs.items():
data[key] = value
return data
def get_translation(self, id_locale):
data = self.translations.filter_by(id_language=id_locale).one()
return {"name": data.name, "description": data.description}
class User(Base):
__tablename__ = 'users'
key = Column(CHAR(40, collation='utf8_unicode_ci'), primary_key=True)
account = Column(CHAR(20, collation='utf8_unicode_ci'), nullable=False)
passwd = Column(CHAR(90, collation='utf8_unicode_ci'))
name = Column(VARCHAR(30, collation='utf8_unicode_ci'), nullable=False)
identity = Column(ENUM('學生', '教師', charset='utf8'), nullable=False)
admin = Column(BOOLEAN, nullable=False)
def __init__(self,
account,
passwd,
name,
identity='學生',
admin=False,
**kwargs):
self.key = uuid.uuid3(uuid.uuid1(), account.encode()).hex
self.account = account
self.name = name
self.identity = identity
self.admin = admin
self.passwd = self.hash_passwd(self.account, passwd)
@staticmethod
def make_salt():
return ''.join(random.choice(string.letters) for i in xrange(5))
@classmethod
def hash_passwd(cls, account, passwd, salt=''):
if not salt:
salt = cls.make_salt()
h = hashlib.sha256(account + passwd + salt).hexdigest()
return '%s,%s' % (h, salt)
def check_passwd(self, passwd):
salt = self.passwd.split(',')[1]
return self.passwd == self.hash_passwd(self.account, passwd, salt)
@classmethod
def by_key(cls, key, sql_session):
q = sql_session.query(cls)
return q.filter(cls.key == key)
def to_dict(self):
return {
'key': self.key,
'name': self.name,
'account': self.account,
'admin': self.admin,
'identity': self.identity,
}
def to_dict_str(self):
_l = []
_map = self.to_dict()
for i in _map:
_l.append("'%s':'%s'" % (i, _map[i]))
return '{%s}' % ','.join(_l)
class KqUserInfo(Base):
__tablename__ = 'kq_user_info'
user_id = Column(BIGINT(20), primary_key=True, comment='员工id')
badge_number = Column(String(24, 'utf8_croatian_ci'), nullable=False, comment='工号')
name = Column(String(40, 'utf8_croatian_ci'), comment='员工名称')
gender = Column(ENUM('M', 'F', ''), comment='性别：M 男 F 女')
notes = Column(String(500, 'utf8_croatian_ci'), comment='备注')
class Frontend(Base):
__tablename__ = 'frontend'
name = Column(VARCHAR, primary_key=True)
bind_address = Column(VARCHAR)
bind_port = Column(INT)
default_backend = Column(VARCHAR)
mode = Column(ENUM('none','tcp','http'))
maxconn = Column(INT)
class UserModel(LoginMixin, db.Model, CommonMixin):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True, comment='主键')
login = db.Column(db.String(20), comment='账号ID')
nickname = db.Column(db.String(20), comment='昵称')
password = db.Column(db.String(128), comment='密码')
role = db.Column(ENUM('admin', 'user'), nullable=False, comment='用户类型')
email = db.Column(db.String(20), comment='email')
comment_ids = db.relationship('CommentModel', backref='user')
post_ids = db.relationship('PostModel', backref='user')
def check(self, password):
"""密码验证"""
return check_password_hash(self.password, password.encode())
@classmethod
def validate_login(cls, form):
"""
验证登陆
:type form: dict
:return: UserModel
:rtype: UserModel
"""
user = UserModel.exist(login=form['login'], role=form['role'])
if user is None:
return None
elif not user.check(form['password']):
return None
return user
@classmethod
def register_user(cls, form):
"""
注册用户
:type form: dict
:rtype: UserModel, str
"""
if form.get('email') and cls.exist(email=form['email']):
return None, 'email is already exist'
if cls.exist(login=form['login']):
return None, 'user is already exist'
user = cls()
user.login = form['login']
user.nickname = form['nickname']
user.email = form.get('email') or ''
user.role = 'user' # 接口只能注册user类型
password = generate_password_hash(form['password'])
user.password = password
db.session.add(user)
db.session.commit()
return user, 'register success'
def asdict(self, columns=None):
if columns is None:
columns = ['id', 'login', 'nickname', 'email', 'role']
return super().asdict(columns)
class Forecasting(Base):
__tablename__ = "forecasting"
"""Summarizes impression count for each page"""
id = Column(Integer, primary_key=True, autoincrement=True)
page_id = Column(Integer, nullable=True, primary_key=True, default=None)
count = Column(BigInteger, nullable=False) # Impressions per month
video_id = Column(Integer, nullable=True, default=None, primary_key=True)
app_id = Column(Integer, nullable=True, primary_key=True, default=None)
country = Column(ENUM(*countries), nullable=False, primary_key=True)
class Blog(db.Model):
__tablename__ = 'Blog'
id = Column(BIGINT(12), primary_key=True)
title = Column(String(140, 'utf8mb4_bin'))
content = Column(Text(collation='utf8mb4_bin'))
status = Column(ENUM('del', 'normal'))
create_time = Column(INTEGER(11))
update_time = Column(INTEGER(11))
class Reminder(Base):
__tablename__ = 'reminders'
id = Column(INT(unsigned=True), primary_key=True)
uid = Column(String(64),
default=lambda: Reminder.create_uid(),
unique=True)
name = Column(String(24), default='Reminder')
message_id = Column(INT(unsigned=True),
ForeignKey(Message.id, ondelete='RESTRICT'),
nullable=False)
message = relationship(Message)
channel_id = Column(INT(unsigned=True),
ForeignKey(Channel.id, ondelete='CASCADE'),
nullable=True)
time = Column(INT(unsigned=True))
enabled = Column(Boolean, nullable=False, default=True)
avatar = Column(
String(512),
default=
'https://raw.githubusercontent.com/reminder-bot/logos/master/Remind_Me_Bot_Logo_PPic.jpg',
nullable=False)
username = Column(String(32), default='Reminder', nullable=False)
interval = Column(INT(unsigned=True))
method = Column(ENUM('remind', 'natural', 'dashboard', 'todo'))
set_by = Column(INT(unsigned=True),
ForeignKey(User.id, ondelete='SET NULL'),
nullable=True)
set_at = Column(TIMESTAMP,
nullable=True,
default=datetime.now,
server_default='CURRENT_TIMESTAMP()')
@staticmethod
def create_uid() -> str:
full: str = ''
while len(full) < 64:
full += secrets.choice(ALL_CHARACTERS)
return full
def message_content(self):
if len(self.message.content) > 0:
return self.message.content
elif self.message.embed is not None:
return self.message.embed.description
else:
return ''
class PurchaseModel(DeclarativeBase):
__tablename__ = 'purchase'
__table_args__ = (Index('id', unique=True), )
id = Column(Integer, primary_key=True)
customer_id = Column(Integer, nullable=False)
status = Column(ENUM('new', 'canceled'), nullable=True)
product_id = Column(Integer, nullable=False)
amount = Column(Numeric(precision=13, scale=2), nullable=True)
date = Column(DateTime)
class Source(db.Model):
__tablename__ = 'sources'
__table_args__ = {'mysql_engine': 'InnoDB', 'mysql_charset': 'utf8'}
id = Column(Integer, primary_key=True)
work_id = Column('author_code',
Integer,
ForeignKey('works.id'),
nullable=False,
key='work_id')
type = Column(ENUM('B', 'C', 'J', 'L', 'M', 'P'), index=True)
citation = Column(Text)
url = Column(Text)
comments = Column(Text)
ordered = Column(Date)
status_code = Column(ENUM('N', 'E', 'M', 'R', 'X', 'XP', 'XR'),
default='N',
index=True)
work = db.relationship('Work',
backref=db.backref('sources', cascade="all,delete"))
class User(db.Model, UserMixin):
__tablename__ = "user_tbl"
__table_args__ = {'mysql_collate': 'utf8_general_ci'}
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.String(12), index=True, unique=True)
user_pw = db.Column(db.String(94))
user_email = db.Column(db.String(120), unique=True)
user_name = db.Column(db.String(64))
user_department = db.Column(db.String(64))
user_grade = db.Column(TINYINT(4, unsigned=True, zerofill=True))
user_gender = db.Column(ENUM('M', 'F'), default='M')
user_membership = db.Column(ENUM('N', 'A'), default='N')
user_registration_date = db.Column(db.DATETIME, default=func.now())
user_about_me = db.Column(db.String(140))
user_last_sign_in = db.Column(db.DateTime, default=datetime.utcnow())
posts = db.relationship('Post', backref='author', lazy='dynamic')
def __init__(self, **kwargs):
self.user_id = kwargs.get('user_id')
self.user_pw = generate_password_hash(kwargs.get('user_pw'))
self.user_name = kwargs.get('user_name')
self.user_email = kwargs.get('user_email')
self.user_department = kwargs.get('user_department')
self.user_grade = kwargs.get('user_grade')
self.user_gender = kwargs.get('user_gender')
def __repr__(self):
return '<USER {}>'.format(self.user_id)
def as_dict(self):
return {x.name: getattr(self, x.name) for x in self.__table__.columns}
def set_user_pw(self, password):
self.user_pw = generate_password_hash(password)
def check_user_pw(self, password):
return check_password_hash(self.user_pw, password)
def avatar(self, size):
digest = md5(self.user_email.lower().encode('utf-8')).hexdigest()
return 'https://www.gravatar.com/avatar/{0}?d=identicon&s={1}'.format(
digest, size)
