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 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 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 Zan(db.Model):
__tablename__ = 'zans'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer())
create_time = db.Column(db.BigInteger())
comment_id = db.Column(db.Integer())
# '0' 为未点赞
liked = db.Column(db.Integer, default=1)
def __init__(self, user_id, comment_id):
self.user_id = user_id
self.comment_id = comment_id
def __repr__(self):
return "<Zan '{}' '{}'>".format(self.id, self.status)
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()
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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 Chess(db.Model):
__tablename__ = 'chess'
id = db.Column(db.Integer, primary_key=True)
room = db.Column(db.String(100), unique=True)
chess_board = db.Column(LONGTEXT)
created_at = db.Column(db.Integer, default=time.time())
def __init__(self, **kwargs):
self.room = kwargs['room']
self.chess_board = kwargs['chess_board']
def __repr__(self):
return "<Chess '{}'>".format(self.room)
def save(self):
db.session.add(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
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 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 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,
},
}
