class Comment(db.Model):
id = db.Column(db.Integer(), primary_key=True)
user_id = db.Column(db.Integer(), db.ForeignKey('user.id'), nullable=False)
text = db.Column(db.Text())
date = db.Column(db.TIMESTAMP(), server_default=func.now())
task_id = db.Column(db.Integer(), db.ForeignKey('task.id'), nullable=False)
def __repr__(self):
return '<Comment: {}>'.format(self.text[:15])
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'))
user_id = db.Column(db.Integer(), db.ForeignKey('user.id'))
def __repr__(self):
return "<Comment '{}'>".format(self.text[:15])
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 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 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 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 FinanceRecord(db.Model):
__tablename__ = "finance_records"
PER_PAGE = 20
BUY = 100 # 购买
COMM = 200 # 推荐成功
EXTRACT = 300 # 提取
WAIT = 100
SUCCESS = 200
id = db.Column(db.Integer, primary_key=True)
source = db.Column(db.Integer(3), nullable=False) #BUY, COMM, EXTRACT
money = db.Column(db.Numeric(9, 2)) # 支出(EXTRACT)为负数
status = db.Column(db.Integer(3), default=WAIT) # WAIT, SUCCESS
created_date = db.Column(db.DateTime, default=datetime.now)
report_id = db.Column(
db.Integer, db.ForeignKey('taoke_reports.id', ondelete='CASCADE'))
report = db.relation('TaokeReport', backref='finance_records')
user_id = db.Column(db.Integer,
db.ForeignKey('users.id', ondelete='CASCADE'))
user = db.relation('User', backref='finance_records')
def __init__(self, *args, **kwargs):
super(FinanceRecord, self).__init__(*args, **kwargs)
def __str__(self):
return u"%s: %s" % (self.user_id, self.money)
def __repr__(self):
return "<%s>" % self
@cached_property
def name(self):
data = {100: u"购买商品", 200: u"推荐分成", 300: u"提现"}
return data.get(self.source, u'未知方式')
@cached_property
def get_status(self):
data = {100: u"等待处理", 200: u"成功"}
return data.get(self.status, u'无状态')
class Myfeeling(db.Model):
id = db.Column(db.Integer(), primary_key=True)
text = db.Column(db.Text())
user_id = db.Column(db.Integer(), db.ForeignKey('user.id'))
timestamp = db.Column(db.DateTime())
def __repr__(self):
return "<My feeling '{}'>".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 Photos(db.Model):
id = db.Column(db.Integer(), primary_key=True)
user_id = db.Column(db.Integer(), db.ForeignKey('user.id'))
timestamp = db.Column(db.DateTime())
pic_url = db.Column(db.Text())
description = db.Column(db.Text())
def __repr__(self):
return "<My Photos '{}'".format(self.text[:15])
class Session(db.Model):
__tablename__ = 'session'
id = db.Column(db.Integer, primary_key=True)
start_time = db.Column(db.DateTime,
server_default=func.now(),
nullable=False)
duration_s = db.Column(db.Integer, nullable=False)
#? 1 course - Many sessions
course_code = db.Column(db.String(7), db.ForeignKey('course.code'))
course = db.relationship('Course', back_populates='sessions')
#? 1 user - Many study blocks
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
user = db.relationship('User', back_populates='sessions')
db.UniqueConstraint(start_time, user_id)
def __repr__(self):
return f"Session<id={self.id}, start={self.start_time}, duration={self.duration_s}, course_code={self.course_code}, user={self.user_id}>"
def save(self):
db.session.add(self)
db.session.commit()
def add_article(self, article):
self.articles.append(article)
self.save()
def remove_article(self, article_id):
article = Article.find_by_id(article_id)
self.articles.remove(article)
self.save()
@classmethod
def find_by_id(cls, session_id):
return cls.query.filter(cls.id == session_id).first()
@classmethod
def find_course_sessions(cls, user_id, course_code):
return cls.query.filter(cls.user_id == user_id).filter(
cls.course_code == course_code).all()
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 Likes(db.Model):
id = db.Column(db.Integer(), primary_key=True)
user_id = db.Column(db.Integer(), nullable=False)
task_id = db.Column(db.Integer(),
db.ForeignKey('task.id'),
index=True,
nullable=False)
liked_user = db.Column(db.Integer(),
db.ForeignKey('user.id'),
index=True,
nullable=False)
def i_like(self, task_id):
task = Task.query.get(task_id)
self.user_id = session['user_id']
self.task_id = task.id
self.liked_user = task.user_id
def __repr__(self):
return '{}'.format(self.user_id)
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 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,
}
class ArticleRatings(db.Model):
__tablename__ = 'article_ratings'
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), primary_key=True)
user = db.relationship('User', back_populates='article_ratings')
article_id = db.Column(db.Integer,
db.ForeignKey('article.id'),
primary_key=True)
rating = db.Column(db.Integer, nullable=False)
def __repr__(self):
return f'Rating<user_id: {self.user_id}, article_id: {self.article_id}, rating: {self.rating}>'
def remove(self):
db.session.delete(self)
db.session.commit()
@classmethod
def find_by_id(cls, user_id, article_id):
return cls.query.filter(cls.user_id == user_id).filter(
cls.article_id == article_id).first()
class Connection(db.Model):
__tablename__ = "connections"
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
provider_id = db.Column(db.String(255))
provider_user_id = db.Column(db.String(255))
access_token = db.Column(db.String(255))
secret = db.Column(db.String(255))
display_name = db.Column(db.String(255))
profile_url = db.Column(db.String(512))
image_url = db.Column(db.String(512))
rank = db.Column(db.Integer)
class Post(db.Model):
id = db.Column(db.Integer(),primary_key=True)
title = db.Column(db.String(255))
text = db.Column(db.Text())
publish_date = db.Column(db.DateTime())
user_id = db.Column(db.Integer(),db.ForeignKey('user.id'))
comments = db.relationship('Comment',backref = 'post',lazy = 'dynamic')
tags=db.relationship(
'Tag',secondary =tags,backref = db.backref('posts',lazy='dynamic')
)
def __init__(self,title):
self.title = title
def __repr__(self):
return "<Post '{}'>".format(self.title)
class Drop(db.Model):
__tablename__ = "drop"
index = db.Column(db.Integer, primary_key=True, autoincrement=True)
quantity = db.Column(db.Integer, nullable=False, default=1)
monster_code = db.Column(db.String(32),
db.ForeignKey("monster.code"),
nullable=False)
monster = db.relationship("Monster",
foreign_keys=[monster_code])
item_code = db.Column(db.String(32),
db.ForeignKey("item_list.code"),
nullable=False)
item = db.relationship("ItemList",
foreign_keys=[item_code])
def to_dict(
self,
item_dict: bool = False,
monster_dict: bool = False
) -> dict:
if item_dict:
return {
"item": self.item.to_dict(with_item_data=True),
"quantity": self.quantity,
}
elif monster_dict:
return {
"monster": self.monster.to_dict(minimal=True),
"quantity": self.quantity,
}
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 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 SkillBook(
db.Model, BaseMixin,
SoldByMixin
):
__tablename__ = "skill_book"
_mapper_utils = {
"files": {
"server": [
"s_SkillBookItem.bin"
],
"client": [
"c_SkillBookItemRes.bin"
],
"string": [
"SkillBookItemStr.dat"
],
},
}
skill_code = CustomColumn(
db.String(32), db.ForeignKey("player_skill.code"),
nullable=False, mapper_key="대상코드")
skill = db.relationship("PlayerSkill", foreign_keys=[skill_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,
"skill": self.skill.to_dict() if self.skill else None,
**SoldByMixin.to_dict(self),
}
class QuestDescription(db.Model):
__tablename__ = "quest_description"
index = db.Column(db.Integer, primary_key=True, autoincrement=True)
language = db.Column(db.String(4), nullable=False)
quest_code = db.Column(db.String(32),
db.ForeignKey("quest.code"),
nullable=False)
title = db.Column(db.Text(256))
mission_1 = db.Column(db.Text(1024))
mission_2 = db.Column(db.Text(1024))
mission_3 = db.Column(db.Text(1024))
description = db.Column(db.Text(2048))
pre_dialog = db.Column(db.Text(2048))
start_dialog = db.Column(db.Text(2048))
run_dialog = db.Column(db.Text(2048))
finish_dialog = db.Column(db.Text(2048))
def to_dict(self) -> dict:
return {
"language": self.language,
"title": self.title,
"missions": [
self.mission_1,
self.mission_2,
self.mission_3,
],
"description": self.description,
"pre_dialog": self.pre_dialog,
"run_dialog": self.run_dialog,
"start_dialog": self.start_dialog,
"finish_dialog": self.finish_dialog,
}
class QuestScroll(
db.Model,
BaseMixin,
DroppedByMixin,
SoldByMixin,
):
__tablename__ = "quest_scroll"
_mapper_utils = {
"files": {
"server": ["s_QuestScrollItem.bin"],
"client": ["c_QuestScrollItemRes.bin"],
"string": ["QuestScrollItemStr.dat"],
},
}
quest_code = CustomColumn(db.String(32),
db.ForeignKey("quest.code"),
nullable=False,
mapper_key="대상코드")
quest = db.relationship("Quest", foreign_keys=[quest_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,
"quest":
self.quest.to_dict(minimal=True) if self.quest else None,
**SoldByMixin.to_dict(self),
**DroppedByMixin.to_dict(self),
}
from webapp.extensions import db
from sqlalchemy.dialects.postgresql import TEXT
# Associatoin table
session_articles = db.Table(
'session_articles',
db.Column('session_id',
db.Integer,
db.ForeignKey('session.id'),
primary_key=True),
db.Column('article_id',
db.Integer,
db.ForeignKey('article.id'),
primary_key=True))
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))
class Monster(db.Model):
__tablename__ = "monster"
_mapper_utils = {
"files": {
"server": ["s_MonsterChar.bin"],
"client": ["c_MonsterCharRes.bin"],
"string": ["MonsterCharStr.dat"],
},
"options": {
"image_key": "모델명"
},
}
index = db.Column(db.Integer, nullable=False)
code = CustomColumn(db.String(32), primary_key=True, mapper_key="코드")
name = CustomColumn(db.String(256), nullable=False, mapper_key="_name")
icon = CustomColumn(db.String(32), nullable=False, mapper_key="_icon")
rating_type = CustomColumn(db.Enum(RatingType),
nullable=False,
mapper_key="몬스터등급타입",
transform=lambda val: RatingType(val))
level = CustomColumn(db.Integer, nullable=False, mapper_key="기준레벨")
hp = CustomColumn(db.Integer, nullable=False, mapper_key="기준최대HP")
range = CustomColumn(db.Enum(MonsterRange),
nullable=False,
mapper_key="공격거리타입",
transform=lambda val: MonsterRange(val))
area = CustomColumn(db.Enum(Area),
nullable=False,
mapper_key="필드구분",
transform=lambda val: Area(val))
experience = CustomColumn(db.Integer, nullable=False, mapper_key="보상경험치")
minimal_damage = CustomColumn(db.Integer,
nullable=False,
mapper_key="최소물공력")
maximal_damage = CustomColumn(db.Integer,
nullable=False,
mapper_key="최대물공력")
physical_defense = CustomColumn(db.Integer,
nullable=False,
mapper_key="물방력")
magic_defense = CustomColumn(db.Integer, nullable=False, mapper_key="마항력")
attack_range = CustomColumn(db.Float,
nullable=False,
mapper_key="기본사정거리",
transform=florensia_meter_transform)
tameable = CustomColumn(db.Boolean, mapper_key="테이밍", nullable=False)
drops = db.relationship(
"Drop", primaryjoin="foreign(Drop.monster_code) == Monster.code")
map_points = db.relationship(
"MapPoint",
primaryjoin="foreign(MapPoint.monster_code) == Monster.code")
quest_missions = db.relationship(
"QuestMission",
primaryjoin="foreign(QuestMission.monster_code) == Monster.code")
vision_range = CustomColumn(db.Float,
nullable=False,
mapper_key="선공시야",
transform=florensia_meter_transform)
# If you perform an action close to the range
# attack vision range of the monster, you will
# also get aggro
attack_vision_range = CustomColumn(db.Float,
nullable=False,
mapper_key="요청시야",
transform=florensia_meter_transform)
messages_code = CustomColumn(db.String(32),
mapper_key="오브젝트채팅",
transform=lambda v: v if v != "#" else None)
monster_message = db.relationship("MonsterMessage", uselist=False)
# Skill 1
skill_1_code = CustomColumn(db.String(32),
db.ForeignKey("monster_skill.code"),
mapper_key="부가Action1코드",
transform=lambda v: v if v != "#" else None)
skill_1_chance = CustomColumn(db.Float,
mapper_key="부가Action1선택율",
transform=florensia_probability_transform)
skill_1 = db.relationship("MonsterSkill", foreign_keys=[skill_1_code])
# Skill 2
skill_2_code = CustomColumn(db.String(32),
db.ForeignKey("monster_skill.code"),
mapper_key="부가Action2코드",
transform=lambda v: v if v != "#" else None)
skill_2_chance = CustomColumn(db.Float,
mapper_key="부가Action2선택율",
transform=florensia_probability_transform)
skill_2 = db.relationship("MonsterSkill", foreign_keys=[skill_2_code])
def to_dict(self, minimal: bool = False) -> dict:
minimal_dict = {
"code": self.code,
"name": self.name,
"icon": self.icon,
"rating": self.rating_type.to_dict(),
"level": self.level,
"area": self.area.to_dict(),
}
if minimal:
return minimal_dict
# Get monster skills as a list
skills = []
for i in range(1, 3):
skill = getattr(self, f"skill_{i}")
if skill:
skill_dict = skill.to_dict()
skill_dict["chance"] = getattr(self, f"skill_{i}_chance")
skills.append(skill_dict)
return {
**minimal_dict, "hp":
self.hp,
"range":
self.range.to_dict(),
"experience":
self.experience,
"minimal_damage":
self.minimal_damage,
"maximal_damage":
self.maximal_damage,
"physical_defense":
self.physical_defense,
"magic_defense":
self.magic_defense,
"attack_range":
self.attack_range,
"tamable":
self.tameable,
"vision_range":
self.vision_range,
"attack_vision_range":
self.attack_vision_range,
"messages":
(self.monster_message.to_dict() if self.monster_message else None),
"skills":
skills,
"map_points":
[point.to_dict(map_dict=True) for point in self.map_points],
"drops": [drop.to_dict(item_dict=True) for drop in self.drops],
"quests": [
mission.quest.to_dict(minimal=True)
for mission in self.quest_missions
]
}
from webapp.extensions import bcrypt, db, loginmanager
from flask_login import UserMixin
from itsdangerous import TimedJSONWebSignatureSerializer as Serializer
from flask import current_app
from datetime import datetime
from markdown import markdown
import bleach
tags = db.Table('post_tags',
db.Column('post_id', db.Integer, db.ForeignKey('post.id')),
db.Column('tag_id', db.Integer, db.ForeignKey('tag.id')))
@loginmanager.user_loader
def load_user(user_id):
return User.query.get(int(user_id))
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))
from webapp.extensions import db
from werkzeug.security import check_password_hash, generate_password_hash
from flask_login import UserMixin, current_user
from sqlalchemy.sql import func
from sqlalchemy.sql.expression import or_, and_
from datetime import datetime
from flask import session
follows = db.Table('follows', db.Column('user_id', db.ForeignKey('user.id')),
db.Column('follow_id', db.ForeignKey('user.id')))
class User(db.Model, UserMixin):
id = db.Column(db.Integer(), primary_key=True)
username = db.Column(db.String(20), unique=True)
bio = db.Column(db.String(100))
gender = db.Column(db.SmallInteger(), default=0) # 1 男 2 女 0 未填写
email = db.Column(db.String(50), unique=True, index=True)
password = db.Column(db.String(255))
reg_date = db.Column(db.TIMESTAMP(), server_default=func.now())
last_login_date = db.Column(db.DateTime())
wb_uid = db.Column(db.String(20))
avatar = db.Column(db.String(500))
tasks = db.relationship('Task', backref='user', lazy='dynamic')
comments = db.relationship('Comment', backref='user', lazy='dynamic')
following = db.relationship('User',
secondary=follows,
primaryjoin=(follows.c.user_id == id),
secondaryjoin=(follows.c.follow_id == id),
class Task(db.Model):
id = db.Column(db.Integer(), primary_key=True)
user_id = db.Column(db.Integer(),
db.ForeignKey('user.id'),
nullable=False,
index=True)
title = db.Column(db.String(100))
text = db.Column(db.Text())
create_time = db.Column(db.TIMESTAMP(), server_default=func.now())
update_time = db.Column(db.DateTime(), onupdate=func.now())
done_time = db.Column(db.DateTime())
deadline = db.Column(db.DateTime(), nullable=False)
status = db.Column(db.SmallInteger(), default=0) # 0：进行中 1：已完成 2：暂停 9：删除
public_level = db.Column(db.SmallInteger(), default=3,
index=True) # 1：仅自己可见 2：我关注的人可见 3：所有人可见
overtime = db.Column(db.Boolean, default=0) # 任务结束后： 0：未超时 1：超时
comment_allowed = db.Column(db.Boolean,
default=1) # 0：禁止评论并隐藏所有评论内容 1：允许评论
comments = db.relationship('Comment', backref='task', lazy='dynamic')
liked = db.relationship('Likes', backref='task', lazy='dynamic')
def __init__(self, title):
self.title = title
def __repr__(self):
return '<Task: {}|User:{}>'.format(self.title, self.user_id)
# 判断任务是否超时
def is_overtime(self):
if self.status == 0 and self.deadline > datetime.now():
return False
elif self.status == 1 and self.overtime == 0:
return False
else:
return True
# 超时时间
def over_time(self):
if self.status == 0 and self.deadline < datetime.now():
over_time = datetime.now() - self.deadline
if over_time.total_seconds() < 3600:
return ''.join(
['已超时',
str(int(over_time.total_seconds() / 60)), '分钟'])
elif 3600 <= over_time.total_seconds() < 86400:
return ''.join(
['已超时',
str(int(over_time.total_seconds() / 3600)), '小时'])
else:
return ''.join(
['已超时',
str(int(over_time.total_seconds() / 86400)), '天'])
elif self.status == 1:
over_time = self.done_time - self.deadline
if over_time.total_seconds() < 3600:
return ''.join(
['超时',
str(int(over_time.total_seconds() / 60)), '分钟完成'])
elif 3600 <= over_time.total_seconds() < 86400:
return ''.join(
['超时',
str(int(over_time.total_seconds() / 3600)), '小时完成'])
else:
return ''.join(
['超时',
str(int(over_time.total_seconds() / 86400)), '天完成'])
else:
pass
# 给任务点赞的所有user_id
def liked_user(self):
return list(u.user_id for u in self.liked.all())
# 判断是否已点赞
def check_liked(self):
if current_user.id in self.liked_user():
return True
# 距离超时一小时
def one_hour_deadline(self):
the_time = self.deadline - datetime.now()
if 0 < the_time.total_seconds() < 3600:
return True
# 判断当前用户是否有权限查看当前task
def task_auth(self):
task_user = User.query.get(self.user_id)
if current_user.id == self.user_id or self.public_level == 3 or (
current_user in task_user.follower.all()
and self.public_level == 2):
return True
else:
return False
