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, }, }