class Role(db.Model, RoleMixin):
__tablename__ = 'roles'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80), unique=True)
permissions = db.Column(db.Integer, default=Permission.LOGIN)
description = db.Column(db.String(255))
class Article(db.Model):
__tablename__ = 'article'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(80), nullable=False)
author = db.Column(db.String(80))
full_text = db.Column(TEXT, nullable=False)
link = db.Column(db.String(250), nullable=False)
sessions = db.relationship('Session',
secondary=session_articles,
lazy='subquery',
backref=db.backref('articles', lazy=True))
# many to many
def __repr__(self):
return f'Article<id={self.id}, title={self.title}, author={self.author}>'
def save(self):
db.session.add(self)
db.session.commit()
@classmethod
def find_by_id(cls, article_id):
return cls.query.filter(cls.id == article_id).first()
@classmethod
def get_articles(cls):
return cls.query.all()
class Course(db.Model):
__tablename__ = 'course'
code = db.Column(db.String(7), primary_key=True)
title = db.Column(db.String(80), nullable=False)
credits = db.Column(db.Integer, nullable=False)
# many -to many with Users
users = db.relationship('User',
secondary=course_list,
lazy='subquery',
backref=db.backref('courses', lazy=True))
sessions = db.relationship('Session', back_populates='course')
def __repr__(self):
return f'Course<code={self.code}, title={self.title}, credits={self.credits}>'
def save(self):
db.session.add(self)
db.session.commit()
@classmethod
def get_courses(cls):
res = cls.query.all()
return res
@classmethod
def find_by_id(cls, code):
course = cls.query.filter(cls.code == code).first()
return course
class SealOptionData(db.Model):
__tablename__ = "seal_option_data"
_mapper_utils = {
"files": {
"server": ["s_SealOptionValueData.bin"]
},
}
code = CustomColumn(db.String(32), primary_key=True, mapper_key="코드")
effect_code = CustomColumn(db.Enum(EffectCode),
nullable=False,
mapper_key="효과코드",
transform=lambda v: EffectCode(v))
operator = CustomColumn(db.String(4),
mapper_key="Operator",
transform=lambda v: v if v != "#" else None)
def to_dict(self) -> dict:
intervalls = {}
for cname in COLUMN_NAMES:
intervalls[cname.lower()] = getattr(self, cname)
return {
"code": self.code,
"effect_code": self.effect_code.to_dict(),
"operator": self.operator,
"intervalls": intervalls,
}
class UserProfile(db.Model):
__tablename__ = 'user_profiles'
PER_PAGE = 20
user_id = db.Column(db.Integer,
db.ForeignKey('users.id', ondelete='CASCADE'),
primary_key=True)
gender = db.Column(db.String(1), default='n') #n, m, f
description = db.Column(db.String(100))
image_url = db.Column(db.String(100))
url = db.Column(db.String(100))
followers_count = db.Column(db.Integer)
verified = db.Column(db.Boolean, default=False)
location = db.Column(db.String(20))
updatetime = db.Column(db.DateTime,
default=datetime.now,
onupdate=datetime.now)
def __init__(self, *args, **kwargs):
super(UserProfile, self).__init__(*args, **kwargs)
def __str__(self):
return self.user_id
def __repr__(self):
return "<%s>" % self
@property
def get_city(self):
r = self.city if self.city else self.province
return r if r else ''
class UserMapper(db.Model):
""" 微博用户授权信息
source: sina, qq
app: 我们下面将会有多个app
"""
__tablename__ = "user_mappers"
id = db.Column(db.Integer, primary_key=True)
access_token = db.Column(db.String(255))
access_secret = db.Column(db.String(255))
source = db.Column(db.String(50))
app = db.Column(db.String(10)) # taoke,
user_id = db.Column(db.Integer,
db.ForeignKey('users.id', ondelete='CASCADE'))
user = db.relation('User', backref='mappers')
def __init__(self, *args, **kwargs):
super(UserMapper, self).__init__(*args, **kwargs)
def __str__(self):
return u"%s - %s(%s)" % (self.user_id, self.app, self.source)
def __repr__(self):
return "<%s>" % self
class Role(db.Model, RoleMixin):
__tablename__ = "roles"
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(80), unique=True)
description = db.Column(db.String(255))
class Map(db.Model):
__tablename__ = "map"
_mapper_utils = {
"files": {
"string": ["AreaStr.dat"],
},
}
code = db.Column(db.String(32), primary_key=True, nullable=False)
name = db.Column(db.String(128), nullable=False)
left = CustomColumn(db.Float)
top = CustomColumn(db.Float)
width = CustomColumn(db.Float)
height = CustomColumn(db.Float)
map_points = db.relationship(
"MapPoint", primaryjoin="foreign(MapPoint.map_code) == Map.code")
def _parse_row(row: dict) -> "Map":
code = row["Code"]
lwth = MAP_CODE_TO_LTWH.get(code, None)
if lwth is None:
# Not a "real" map but rather island or an area
# which only have a name and code
return {"code": code, "name": row[LANGUAGE]}
l, t, w, h = [float(num) for num in lwth.split(",")]
return {
"code": code,
"name": row[LANGUAGE],
"left": l,
"top": t,
"width": w,
"height": h,
}
def to_dict(self, minimal: bool = False) -> dict:
minimal_dict = {
"code": self.code,
"name": self.name,
"left": self.left,
"top": self.top,
"width": self.width,
"height": self.height,
}
if minimal:
return minimal_dict
return {
**minimal_dict, "points":
[point.to_dict(monster_dict=True) for point in self.map_points]
}
class QuestItem(db.Model, DroppedByMixin):
__tablename__ = "quest_item"
_mapper_utils = {
"files": {
"server": ["s_QuestItem.bin"],
"client": ["c_QuestItemRes.bin"],
"string": ["QuestItemStr.dat"],
},
}
index = db.Column(db.Integer, nullable=False)
code = CustomColumn(db.String(32),
primary_key=True,
nullable=False,
mapper_key="코드")
name = CustomColumn(db.String(256), nullable=False, mapper_key="_name")
icon = CustomColumn(db.String(32), nullable=False, mapper_key="_icon")
stack_size = CustomColumn(db.Integer, nullable=False, mapper_key="중복가능수")
quest_missions = db.relationship(
"QuestMission",
primaryjoin="foreign(QuestMission.quest_item_code) == QuestItem.code",
)
quest_give_items = db.relationship(
"QuestGiveItem",
primaryjoin="foreign(QuestGiveItem.item_code) == QuestItem.code",
)
def to_dict(self, minimal: bool = False) -> dict:
minimal_dict = {
"code": self.code,
"name": self.name,
"icon": self.icon,
}
if minimal:
return minimal_dict
quest_objectives = self.quest_missions + self.quest_give_items
return {
**minimal_dict,
"stack_size":
self.stack_size,
"quests": [
quest_objective.quest.to_dict(minimal=True)
for quest_objective in quest_objectives
],
**DroppedByMixin.to_dict(self),
}
class MapPoint(db.Model):
__tablename__ = "map_point"
index = db.Column(db.Integer, primary_key=True, autoincrement=True)
map_code = db.Column(db.String(32),
db.ForeignKey("map.code"),
nullable=False)
map = db.relationship("Map", foreign_keys=[map_code])
monster_code = db.Column(db.String(32),
db.ForeignKey("monster.code"),
nullable=False)
monster = db.relationship("Monster", foreign_keys=[monster_code])
x = db.Column(db.Integer, nullable=False)
y = db.Column(db.Integer, nullable=False)
z = db.Column(db.Integer, nullable=False)
def to_dict(
self,
monster_dict: bool = False,
map_dict: bool = False,
) -> dict:
if monster_dict:
return {
"monster": self.monster.to_dict(minimal=True),
"pos": {
"x": self.x,
"y": self.y,
"z": self.z,
},
}
elif map_dict:
return {
"map": self.map.to_dict(minimal=True),
"pos": {
"x": self.x,
"y": self.y,
"z": self.z,
},
}
return {
"map": self.map.to_dict(minimal=True),
"monster": self.monster.to_dict(minimal=True),
"pos": {
"x": self.x,
"y": self.y,
"z": self.z,
},
}
class GenomeCategory(db.Model):
__tablename__ = "genome_categories"
chromosome_id = db.Column(db.Integer, primary_key=True)
category = db.Column(db.String(64))
sub_category = db.Column(db.String(64))
chromosome = db.Column(db.String(64))
measure_type = db.Column(db.String(32))
category_order = db.Column(db.Integer)
normalization_method = db.Column(db.String(32))
normalization_factor = db.Column(db.Integer)
class Blog(db.Model):
__tablename__ = 'blogs'
__searchable__ = ['title', 'content']
__analyzer__ = ChineseAnalyzer()
id = db.Column(db.Integer, primary_key=True)
time = db.Column(db.BigInteger)
author = db.Column(db.String(255))
title = db.Column(db.String(255), unique=True)
content = db.Column(LONGTEXT)
comments = db.relationship('Comment', backref='blogs', lazy='dynamic')
tags = db.relationship('Tag', secondary=tags, backref=db.backref('blogs', lazy='dynamic'))
def __init__(self, author, title, content):
self.author = author
self.title = title
self.content = content
def __repr__(self):
return "<Blog '{}'>".format(self.title)
def save(self):
db.session.add(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
def to_dict(self):
"""Transforms a model into a dictionary which can be dumped to JSON."""
# first we get the names of all the columns on your model
columns = [c.key for c in class_mapper(self.__class__).columns]
# then we return their values in a dict
return dict((c, getattr(self, c)) for c in columns)
# 返回除了 content, comments 之外的值
@staticmethod
def query_title():
sql_str = '''
SELECT blogs.id, blogs.time, blogs.author, blogs.title, group_concat(tags.title) tag
FROM blogs LEFT JOIN blog_tags ON blogs.id=blog_tags.blog_id
left join tags ON tags.id=blog_tags.tag_id
group by blogs.id;
'''
ret = db.engine.execute(sql_str).fetchall()
return [dict(r) for r in ret]
class PetSkillStone(
db.Model,
BaseMixin,
DroppedByMixin,
RandomBoxMixin,
):
__tablename__ = "pet_skill_stone"
_mapper_utils = {
"files": {
"server": ["s_PetSkillStoneItem.bin"],
"client": ["c_PetSkillStoneItemRes.bin"],
"string": ["PetSkillStoneItemStr.dat"],
}
}
skill_code = CustomColumn(db.String(32),
db.ForeignKey("pet_skill.code"),
nullable=False,
mapper_key="대상코드")
skill_data = db.relationship("PetSkill", foreign_keys=[skill_code])
def to_dict(self, minimal: bool = False) -> dict:
minimal_dict = BaseMixin.to_dict(self, minimal)
if minimal:
return minimal_dict
return {
**minimal_dict,
"skill": self.skill_data.to_dict(),
**DroppedByMixin.to_dict(self),
**RandomBoxMixin.to_dict(self),
}
class Tag(db.Model):
__tablename__ = 'tags'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(255), unique=True)
def __init__(self, title):
self.title = title
def __repr__(self):
return "<Tag '{}'>".format(self.title)
def save(self):
db.session.add(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
@staticmethod
def tag_blogs(tag_id):
sql_str = '''
SELECT blogs.id AS id, blogs.time AS time, blogs.author AS author, blogs.title AS title, tags.title AS tags
FROM blogs, blog_tags, tags
WHERE {} = blog_tags.tag_id AND blogs.id = blog_tags.blog_id AND tags.id = {}
'''.format(tag_id, tag_id)
ret = db.engine.execute(sql_str).fetchall()
return [dict(r) for r in ret]
class ProductBook(db.Model, BaseMixin, SoldByMixin):
__tablename__ = "product_book"
_mapper_utils = {
"files": {
"server": ["s_ProductBook.bin"],
"client": ["c_ProductRes.bin"],
"string": ["ProductStr.dat"],
},
}
production_code = CustomColumn(db.String(32),
db.ForeignKey("production.code"),
nullable=False,
mapper_key="대상코드")
production = db.relationship("Production",
foreign_keys=[production_code],
uselist=False)
def to_dict(self, minimal: bool = False) -> dict:
minimal_dict = BaseMixin.to_dict(self, minimal)
if minimal:
return minimal_dict
return {
**minimal_dict,
"production": self.production.to_dict(minimal=True),
**SoldByMixin.to_dict(self),
}
class User(db.Model):
__tablename__ = "user"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(128), nullable=False, unique=True)
password = db.Column(db.String(2048), nullable=False)
created_at = db.Column(db.DateTime, nullable=False, default=get_utc_now)
updated_at = db.Column(db.DateTime, onupdate=get_utc_now)
admin = db.Column(db.Boolean, default=False)
can_edit_drops = db.Column(db.Boolean, default=False)
premium = db.Column(db.Boolean, default=False)
def get_jwt_content(self) -> dict:
"""Returns the content that is included in the JWT.
Returns:
dict: dict with string string pairs.
"""
return {
"id": self.id,
"username": self.username,
"admin": self.admin,
"can_edit_drops": self.admin or self.can_edit_drops,
"premium": self.admin or self.premium,
}
def set_password(self, password: str) -> None:
"""Sets a password has from the given password to the user object.
Args:
password (str): The password to set.
"""
pw_hash = generate_password_hash(password)
self.password = pw_hash
def check_password(self, password) -> bool:
"""Compares user password hash to given password
Args:
password (str): Given user password.
Returns:
bool: True if passwords match, False if not.
"""
return check_password_hash(self.password, password)
class Tag(db.Model):
id = db.Column(db.Integer(),primary_key=True)
title = db.Column(db.String(255))
def __init__(self,title):
self.title = title
def __repr__(self):
return "<Tag '{}'>".format(self.title)
class TaokeReport(db.Model):
__tablename__ = "taoke_reports"
PER_PAGE = 20
id = db.Column(db.Integer, primary_key=True)
outer_code = db.Column(db.String(12), index=True) # 6位一个用户shorten
trade_id = db.Column(db.String(20))
num_iid = db.Column(db.String(50))
item_title = db.Column(db.String(200))
item_num = db.Column(db.Integer)
shop_title = db.Column(db.String(50))
seller_nick = db.Column(db.String(50))
pay_time = db.Column(db.DateTime)
pay_price = db.Column(db.Numeric(9, 2))
real_pay_fee = db.Column(db.Numeric(9, 2)) # 实际支付金额
commission = db.Column(db.Numeric(9, 2)) # 用户获得拥金
commission_rate = db.Column(db.String(10)) # 拥金比率
__mapper_args__ = {'order_by': id.desc()}
def __init__(self, *args, **kwargs):
super(TaokeReport, self).__init__(*args, **kwargs)
def __str__(self):
return u"%s: %s" % (self.trand_id, self.item_title)
def __repr__(self):
return "<%s>" % self
class QuestMission(db.Model):
__tablename__ = "quest_mission"
index = db.Column(db.Integer, primary_key=True, autoincrement=True)
work_type = db.Column(db.Enum(QuestWorkType), nullable=False)
work_value = db.Column(db.String(32))
quest_code = db.Column(db.String(32),
db.ForeignKey("quest.code"),
nullable=False)
quest = db.relationship("Quest", foreign_keys=[quest_code])
map_code = db.Column(db.String(32), db.ForeignKey("map.code"))
map = db.relationship("Map", foreign_keys=[map_code], uselist=False)
x = db.Column(db.Float)
y = db.Column(db.Float)
count = db.Column(db.Integer, nullable=False)
npc_code = db.Column(db.String(32), db.ForeignKey("npc.code"))
npc = db.relationship("Npc", foreign_keys=[npc_code], uselist=False)
item_code = db.Column(db.String(32), db.ForeignKey("item_list.code"))
item = db.relationship("ItemList", foreign_keys=[item_code], uselist=False)
monster_code = db.Column(db.String(32), db.ForeignKey("monster.code"))
monster = db.relationship("Monster",
foreign_keys=[monster_code],
uselist=False)
quest_item_code = db.Column(db.String(32),
db.ForeignKey("quest_item.code"))
quest_item = db.relationship("QuestItem",
foreign_keys=[quest_item_code],
uselist=False)
def to_dict(self) -> dict:
return {
"work_type":
self.work_type.to_dict(),
"work_value":
self.work_value,
"map": (self.map.to_dict(minimal=True) if self.map else None),
"pos": {
"x": self.x,
"y": self.y,
},
"count":
self.count,
"npc":
self.npc.to_dict(minimal=True) if self.npc else None,
"item":
self.item.to_dict() if self.item else None,
"monster":
(self.monster.to_dict(minimal=True) if self.monster else None),
"quest_item": (self.quest_item.to_dict(
minimal=True) if self.quest_item else None)
}
class RankingPlayerHistory(db.Model):
__tablename__ = "ranking_player_history"
index = db.Column(db.Integer, primary_key=True, autoincrement=True)
server = db.Column(db.Enum(Server), nullable=False)
name = db.Column(db.String(16), nullable=False)
previous_level_land = db.Column(db.Integer)
new_level_land = db.Column(db.Integer)
previous_level_sea = db.Column(db.Integer)
new_level_sea = db.Column(db.Integer)
previous_character_class = db.Column(db.Enum(CharacterClass))
new_character_class = db.Column(db.Enum(CharacterClass))
previous_guild = db.Column(db.String(16))
new_guild = db.Column(db.String(16))
inserted_at = db.Column(db.DateTime, default=get_utc_now)
def to_dict(self) -> dict:
changes = {}
if self.previous_level_land:
changes["previous_level_land"] = self.previous_level_land
changes["new_level_land"] = self.new_level_land
if self.previous_level_sea:
changes["previous_level_sea"] = self.previous_level_sea
changes["new_level_sea"] = self.new_level_sea
if self.previous_character_class:
changes["previous_character_class"] = (
self.previous_character_class.to_dict())
changes["new_character_class"] = self.new_character_class.to_dict()
if self.previous_guild or self.new_guild:
changes["previous_guild"] = self.previous_guild
changes["new_guild"] = self.new_guild
return {
"inserted_at": str(self.inserted_at),
"changes": changes,
}
class Comment(db.Model):
id=db.Column(db.Integer(),primary_key = True)
name = db.Column(db.String(255))
text = db.Column(db.Text())
date = db.Column(db.DateTime())
post_id = db.Column(db.Integer(),db.ForeignKey('post.id'))
def __repr__(self):
return "<Comment '{}'>".format(self.text[:15])
class Messageboard(db.Model):
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(255))
text = db.Column(db.Text())
timestamp = db.Column(db.DateTime())
user_id = db.Column(db.Integer(), db.ForeignKey('user.id'))
def __repr__(self):
return "<Messageboard '{}'>".format(self.text[:15])
class Post(db.Model):
id = db.Column(db.Integer(), primary_key=True)
title = db.Column(db.String(255))
subtitle = db.Column(db.String(255))
text = db.Column(db.Text())
publish_date = db.Column(db.DateTime())
private = db.Column(db.Boolean())
user_id = db.Column(db.Integer(), db.ForeignKey('user.id'))
comments = db.relationship('Comment', backref='post', lazy='dynamic')
body_html = db.Column(db.Text())
tags = db.relationship('Tag',
secondary=tags,
backref=db.backref('posts', lazy='dynamic'))
'''
@staticmethod
def on_changed_body(target,value,oldvalue,intitiator):
allowed_tag = ['a','abbr','acronym','b','blockquote','code','div','em','i','li','ol','pre','strong','table','thead','tbody','tr','th','ul','h1','h2','h3','h4','h5','h6','p',]
target.body_html = bleach.linkify(bleach.clean(markdown(value,output_html = 'html'),tags=allowed_tag,strip=True))
'''
#处理body字段变化的函数
@staticmethod
def on_changed_post(target, value, oldvalue, initiaor):
allow_tags = [
'a', 'abbr', 'acronym', 'b', 'blockquote', 'code', 'em', 'i', 'li',
'ol', 'pre', 'strong', 'ul', 'h1', 'h2', 'h3', 'p', 'img'
]
#转换markdown为html，并清洗html标签
target.body_html = bleach.linkify(
bleach.clean(
markdown(value,
output_form='html',
extensions=['extra', 'codehilite']),
tags=allow_tags,
strip=True,
attributes={
'*': ['class'],
'a': ['href', 'rel'],
'img': ['src', 'alt'], #支持<img src …>标签和属性
}))
def __repr__(self):
return "<Post '{}'>".format(self.title)
class MonsterMessage(db.Model):
__tablename__ = "monster_message"
_mapper_utils = {
"files": {
"server": [
],
"client": [
"c_ObjChat.bin"
],
"string": [
"ObjChatDesc.dat"
],
},
"options": {
"image_key": "모델명"
},
}
code = CustomColumn(db.String(32), db.ForeignKey("monster.messages_code"),
primary_key=True, nullable=False, mapper_key="대사코드")
idle_0 = CustomColumn(db.Text, mapper_key="Idle0")
idle_1 = CustomColumn(db.Text, mapper_key="Idle1")
attack_0 = CustomColumn(db.Text, mapper_key="Attack0")
attack_1 = CustomColumn(db.Text, mapper_key="Attack1")
damage_0 = CustomColumn(db.Text, mapper_key="Damage0")
damage_1 = CustomColumn(db.Text, mapper_key="Damage1")
critical_0 = CustomColumn(db.Text, mapper_key="Critical0")
critical_1 = CustomColumn(db.Text, mapper_key="Critical1")
die_0 = CustomColumn(db.Text, mapper_key="Die0")
die_1 = CustomColumn(db.Text, mapper_key="Die1")
regen_0 = CustomColumn(db.Text, mapper_key="ObjRegen0")
regen_1 = CustomColumn(db.Text, mapper_key="ObjRegen1")
def to_dict(self) -> dict:
strings = ["idle", "attack", "damage", "critical",
"die", "regen"]
resp = {}
for string in strings:
resp[string] = []
for i in range(0, 2):
value = getattr(self, f"{string}_{i}")
if value:
resp[string].append(value)
return resp
class GenomeRule(db.Model):
__tablename__ = "genome_rules"
gr_id = db.Column(db.Integer, primary_key=True)
category = db.Column(db.String(64))
sub_category = db.Column(db.String(64))
gene_name = db.Column(db.String(128))
gene_code = db.Column(db.String(128))
bitmask = db.Column(db.Integer)
function = db.Column(db.String(64))
parameters = db.Column(db.String(256))
chromosome = db.Column(db.String(64))
chromosome_id = db.Column(db.Integer)
gene_usage = db.Column(db.String(32))
weight = db.Column(db.Integer)
gene_source = db.Column(db.String(64))
class ItemList(db.Model):
__tablename__ = "item_list"
code = db.Column(db.String(32),
primary_key=True)
name = db.Column(db.String(256),
nullable=False)
icon = db.Column(db.String(32),
nullable=False)
table = db.Column(db.String(64),
nullable=False)
rare_grade = db.Column(db.Integer,
nullable=False,
default=0)
duration = db.Column(db.Float)
# All item data encoded as json
item_data = db.Column(db.Text, nullable=False)
def to_dict(self, with_item_data: bool = False) -> dict:
minimal_dict = {
"code": self.code,
"name": self.name,
"icon": self.icon,
"table": self.table,
"rare_grade": self.rare_grade,
"duration": self.duration,
}
if not with_item_data:
return minimal_dict
return {
**minimal_dict,
"item_data": json.loads(self.item_data),
}
class User(UserMixin,db.Model):
id =db.Column(db.Integer(),primary_key = True)
email = db.Column(db.String(64),unique = True,index = True)
username = db.Column(db.String(255))
password = db.Column(db.String(255))
posts = db.relationship('Post',backref = 'user',lazy = 'dynamic')
def __repr__(self):
return "<User '{}'>".format(self.username)
def set_password (self,password):
self.password = bcrypt.generate_password_hash(password)
def check_password(self,password):
return bcrypt.check_password_hash(self.password,password)
class Message(db.Model):
__tablename__ = 'messages'
id = db.Column(db.Integer, primary_key=True)
time = db.Column(db.BigInteger)
# 1 表示已经查看， 0 表示未查看
checked = db.Column(db.String(10))
sender = db.Column(db.String(255))
content = db.Column(db.String(1000))
href = db.Column(db.String(1000))
message_type = db.Column(db.String(1000))
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
def __init__(self, sender, content):
self.sender = sender
self.content = content
def save(self):
db.session.add(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
@staticmethod
def roll_back():
db.session.rollback()
# 查询指定用户的 unchecked messages
@staticmethod
def user_unchecked_messages(user_id):
sql = '''
SELECT messages.id, messages.sender, messages.checked, messages.content, messages.time
FROM messages
WHERE messages.user_id={} AND messages.checked='0'
'''.format(user_id)
ret = db.engine.execute(sql).fetchall()
return [dict(r) for r in ret]
class User(UserMixin, db.Model):
id = db.Column(db.Integer(), primary_key=True)
email = db.Column(db.String(64), unique=True, index=True)
location = db.Column(db.String(64))
about_me = db.Column(db.Text())
member_since = db.Column(db.DateTime(), default=datetime.utcnow)
last_seen = db.Column(db.DateTime(), default=datetime.utcnow)
name = db.Column(db.String(64), unique=True)
username = db.Column(db.String(255))
password = db.Column(db.String(255))
birthday = db.Column(db.Date())
posts = db.relationship('Post', backref='user', lazy='dynamic')
headimg = db.Column(db.String(128), default=None)
comments = db.relationship('Comment', backref='user', lazy='dynamic')
messagesboard = db.relationship('Messageboard',
backref='user',
lazy='dynamic')
myphotos = db.relationship('Photos', backref='user', lazy='dynamic')
def __repr__(self):
return "<User '{}'>".format(self.username)
def set_password(self, password):
self.password = bcrypt.generate_password_hash(password)
def check_password(self, password):
return bcrypt.check_password_hash(self.password, password)
def ping(self):
self.last_seen = datetime.utcnow()
db.session.add(self)
db.session.commit()
class QuestSelectableItem(db.Model):
__tablename__ = "quest_selectable_item"
index = db.Column(db.Integer, primary_key=True, autoincrement=True)
quest_code = db.Column(db.String(32),
db.ForeignKey("quest.code"),
nullable=False)
quest = db.relationship("Quest", foreign_keys=[quest_code])
item_code = db.Column(db.String(32),
db.ForeignKey("item_list.code"),
nullable=False)
item = db.relationship("ItemList", foreign_keys=[item_code], uselist=False)
amount = db.Column(db.Integer, nullable=False)
def to_dict(self) -> dict:
return {
"item": self.item.to_dict(),
"amount": self.amount,
}
