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