class Post(db.Model): __tablename__ = "Post" user_id = db.Column(db.Integer, db.ForeignKey('User.user_id')) post_id = db.Column(db.Integer, primary_key=True) username = db.Column(db.VARCHAR(30)) text = db.Column(db.VARCHAR(30)) course = db.Column(db.VARCHAR(20))
class FeedbackModel(db.Model): __tablename__ = 'feedback' id = db.Column(db.BigInteger, primary_key=True) id_1 = db.Column(db.VARCHAR(255)) id_2 = db.Column(db.VARCHAR(255)) duplicated = db.Column(db.BOOLEAN) creator = db.Column(db.VARCHAR(255)) create_date = db.Column(db.DATETIME) def __init__(self, id_1, id_2, duplicated, creator): self.id_1 = id_1 self.id_2 = id_2 self.duplicated = duplicated self.creator = creator self.create_date = datetime.datetime.now() def json(self): return { 'id': self.id, 'id_1': self.id_1, 'id_2': self.id_2, 'duplicated': self.duplicated, 'creator': self.creator, 'create_date': str(self.create_date) } def save_to_db(self): db.session.add(self) db.session.commit() @staticmethod def get_by_id(fid): return db.session.query(FeedbackModel).filter( FeedbackModel.id == fid).first()
class UserModel(db.Model): __tablename__ = 'users' id = db.Column(db.Integer, primary_key=True) username = db.Column(db.VARCHAR(50)) password = db.Column(db.VARCHAR(50)) def __init__(self, username, password): self.username = username self.password = password def json(self): return {'username': self.username, 'password': self.password} def save_to_db(self): db.session.add(self) db.session.commit() @classmethod def find_by_username(cls, username): return cls.query.filter_by(username=username).first() @classmethod def find_by_id(cls, _id): return cls.query.filter_by(id=_id).first()
class ViewsModel(db.Model): __tablename__ = 'views' sno = db.Column(db.INTEGER, autoincrement=True, primary_key=True) source = db.Column(db.VARCHAR(6), db.ForeignKey('active.uid'), nullable=False) target = db.Column(db.VARCHAR(8), db.ForeignKey('stories.sid'), nullable=False) time = db.Column(db.TIMESTAMP, nullable=False) def create_entry(self): try: db.session.add(self) db.session.commit() except SQLAlchemyError: db.session.rollback() return ERROR_WRITING_VIEWS_TABLE def delete_entry(self): try: db.session.delete(self) db.session.commit() except SQLAlchemyError: db.session.rollback() return ERROR_DELETING_VIEWS_TABLE
class SimilaritiesModel(db.Model): __tablename__ = 'similarities' __table_args__ = (db.PrimaryKeyConstraint('id_1', 'id_2'), ) id_1 = db.Column(db.VARCHAR(255), primary_key=True) id_2 = db.Column(db.VARCHAR(255), primary_key=True) jaccard = db.Column(db.FLOAT) dice = db.Column(db.FLOAT) cosine = db.Column(db.FLOAT) wmd = db.Column(db.FLOAT) duplicated = db.Column(db.BOOLEAN) def json(self): return { 'id_1': self.parse_id(self.id_1), 'id_2': self.parse_id(self.id_2), 'jaccard': self.jaccard, 'dice': self.dice, 'consine': self.cosine, 'wmd': self.wmd, 'duplicated': self.duplicated } @staticmethod def filter(min_cosine, max_cosine, duplicated, user): # the user has already given his feedback on these pairs of trials existing_pairs = [ x.json() for x in db.session.query(FeedbackModel).filter( FeedbackModel.creator == user).all() ] all_pairs = [ x.json() for x in db.session.query(SimilaritiesModel).filter( SimilaritiesModel.cosine >= min_cosine). filter(SimilaritiesModel.cosine <= max_cosine).filter( SimilaritiesModel.duplicated == duplicated).limit(100).all() ] new_pairs = [] for p in all_pairs: is_valid = True for ep in existing_pairs: if p['id_1'] == ep['id_1'] and p['id_2'] == ep['id_2']: is_valid = False break if is_valid: new_pairs.append(p) return new_pairs def parse_id(self, id_val): if 'CTRI' in id_val: return id_val.replace('-', '/') elif 'Outside-EU-EEA' in id_val: return id_val.replace('Outside-EU-EEA', 'Outside-EU/EEA') else: return id_val
class FaceStory(db.Model): """ 一个自拍记录 """ id = db.Column(db.Integer, primary_key=True, autoincrement=True) # 微信用户id openid = db.Column(db.VARCHAR(1024)) # 昵称 nick_name = db.Column(db.VARCHAR(256), nullable=False) # 用户头像 avatar_url = db.Column(db.VARCHAR(1024), nullable=False) # 这三个数据经常用到,这里冗余存起来 # 日期 date = db.Column(db.DateTime) # 自拍结果 story_json = db.Column(db.TEXT) # 点赞 like = db.Column(db.Integer, default=0) # 是否分享到广场 in_square = db.Column(db.Boolean, default=False) def to_dict(self): d = dict() d['id'] = self.id d['nick_name'] = self.nick_name d['avatar_url'] = self.avatar_url d['openid'] = self.openid d['story_json'] = json.loads(self.story_json) d['date'] = self.date.strftime("%Y-%m-%d %H:%M:%S") d['like'] = self.like d['in_square'] = self.in_square return d def __init__(self, openid, nick_name, avatar_url, story_json, like=0, in_square=False): self.openid = openid self.nick_name = nick_name self.avatar_url = avatar_url self.date = datetime.utcnow() self.story_json = story_json self.like = like self.in_square = in_square def __repr__(self) -> str: return "<FaceStory " + str( self.id) + self.openid + " " + self.nick_name + " " + str( self.date) + " " + str(self.like) + str(self.in_square) + ">"
class TagModel(db.Model): __tablename__ = 'Web-scraper-data' __table_args__ = {'schema': 'nsds'} url_id = db.Column(db.Integer, db.ForeignKey('nsds.Web-scraper-URLs.uid')) tag_name = db.Column(db.VARCHAR(length=MAX_LEN), primary_key=True) tag_data = db.Column(db.VARCHAR(length=MAX_LEN)) tag_key = db.Column(db.VARCHAR(length=MAX_LEN), primary_key=True) parent = db.relationship('URL_Model', primaryjoin=url_id == URL_Model.uid) def json(self): return { "tag_name": self.tag_name, "tag_data": self.tag_data, "tag_key": self.tag_key } def __init__(self, url_id, tag_name, tag_data, tag_key): self.url_id = url_id self.tag_name = tag_name self.tag_data = tag_data self.tag_key = tag_key @classmethod def find_tag(cls, url_id, tag_name, tag_key): return cls.query.filter_by(url_id=url_id, tag_name=tag_name, tag_key=tag_key).first() @classmethod def find_all_by_url_id(cls, url_id): return cls.query.filter_by(url_id=url_id) @classmethod def find_all(cls): return cls.query.all() @classmethod def save_list_to_db(cls, lst): try: for i in lst: db.session.add(i) except: db.session.rollback() raise Exception('Error saving to database') db.session.commit() def save_to_db(self): db.session.add(self) db.session.commit() def delete_from_db(self): db.session.delete(self) db.session.commit()
class LikesModel(db.Model): __tablename__ = 'likes' sno = db.Column(db.INTEGER, autoincrement=True, primary_key=True) source = db.Column(db.VARCHAR(6), db.ForeignKey('active.uid'), nullable=False) target = db.Column(db.VARCHAR(8), db.ForeignKey('stories.sid'), nullable=False) time = db.Column(db.TIMESTAMP, nullable=False) @classmethod def generate_favourites_profile_data(cls, active_user_object): if active_user_object.basic is not None: if active_user_object.basic.private: return {'message': IS_PRIVATE} if active_user_object.basic is None: return [ { 'uid': like.liked.uid, 'sid': like.liked.sid, 'name': like.liked.author.name, 'summary': like.liked.summary, 'title': like.liked.title } for like in active_user_object.favourites ] @classmethod def force_generate_favourites_profile_data(cls, active_user_object): return [ { 'uid': like.liked.uid, 'sid': like.liked.sid, 'name': like.liked.author.name, 'summary': like.liked.summary, 'title': like.liked.title } for like in active_user_object.favourites ] def create_entry(self): try: db.session.add(self) db.session.commit() except SQLAlchemyError: db.session.rollback() return ERROR_WRITING_LIKE_TABLE def delete_entry(self): try: db.session.delete(self) db.session.commit() except SQLAlchemyError: db.session.rollback() return ERROR_DELETING_LIKE_TABLE
class Feed(db.Model): # 订阅源 __tablename__ = 'feed' id = db.Column(INTEGER(unsigned=True), primary_key=True, autoincrement=True) # primary key url = db.Column(db.String(255), unique=True, index=True) # feed url name = db.Column(db.VARCHAR(120)) # feed name desc = db.Column(db.VARCHAR(255)) # feed description last_fetch = db.Column(db.DateTime) # last fetch time create_time = db.Column(db.DateTime, default=datetime.utcnow) subscribe = db.relationship('Subscribe', backref='feed') collect = db.relationship('Collect', backref='feed') item = db.relationship('Item', backref='feed') def __repr__(self): return '<Feed {}>'.format(self.url)
class URL_Model(db.Model): __tablename__ = 'Web-scraper-URLs' __table_args__ = {'schema': 'nsds'} uid = db.Column(db.Integer, primary_key=True, autoincrement=True) url = db.Column(db.VARCHAR(length=MAX_LEN), primary_key=True) children = db.relationship('TagModel', lazy='dynamic') @validates('url') def validate_tag(self, key, value): value = str(value) if len(value) > MAX_LEN: return value[:MAX_LEN] return value def __init__(self, url): self.url = url @classmethod def find_by_url(cls, url): return cls.query.filter_by(url=url).first() def save_to_db(self): db.session.add(self) db.session.commit() def delete_from_db(self): db.session.delete(self) db.session.commit()
class ItemModel(db.Model): __tablename__ = 'items' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.VARCHAR(50)) price = db.Column(db.Float(precision=2)) store_id = db.Column(db.Integer, db.ForeignKey('stores.id')) store = db.relation('StoreModel') def __init__(self, name, price, store_id): self.name = name self.price = price self.store_id = store_id def json(self): return {'name': self.name, 'price': self.price} @classmethod def find_by_name(cls, name): return cls.query.filter_by(name=name).first() def save_to_db(self): db.session.add(self) db.session.commit() def delete_from_db(self): db.session.delete(self) db.session.commit()
class StoreModel(db.Model): __tablename__ = 'stores' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.VARCHAR(50)) items = db.relation('ItemModel', lazy='dynamic') def __init__(self, name): self.name = name def json(self): return { 'name': self.name, 'items': [item.json() for item in self.items.all()] } @classmethod def find_by_name(cls, name): return cls.query.filter_by(name=name).first() def save_to_db(self): db.session.add(self) db.session.commit() def delete_from_db(self): db.session.delete(self) db.session.commit()
class DataModel(db.Model): __tablename__ = 'API_data' __table_args__ = {'schema': 'nsds'} login = db.Column(db.VARCHAR(length=200), primary_key=True) id = db.Column(db.Integer, primary_key=True) node_id = db.Column(db.Text) url = db.Column(db.Text) avatar_url = db.Column(db.Text) description = db.Column(db.Text) def __init__(self, login, _id, node_id, url, avatar_url, description): self.login = login self.id = _id self.node_id = node_id self.url = url self.avatar_url = avatar_url self.description = description def json(self): return { "login": self.login, "id": self.id, "node_id": self.node_id, "url": self.url, "avatar_url": self.avatar_url, "description": self.description } @classmethod def find_by_login(cls, login): return cls.query.filter_by(login=login).first() @classmethod def find_by_id(cls, _id): return cls.query.filter_by(id=_id).first() @classmethod def find_all(cls): return cls.query.all() @classmethod def save_list_to_db(cls, lst): try: for i in lst: db.session.add(i) except: session.rollback() raise Exception('Error saving to database') db.session.commit() def save_to_db(self): db.session.add(self) db.session.commit() def delete_from_db(self): db.session.delete(self) db.session.commit()
class Session(db.Model): id = db.Column(db.Integer, primary_key=True) code = db.Column(db.VARCHAR(length=255), nullable=False) active = db.Column(db.Boolean, nullable=False) current_location_id = db.Column(db.Integer, db.ForeignKey(Location.id), nullable=False) previous_location_id = db.Column(db.Integer, db.ForeignKey(Location.id), nullable=False) current_location = relationship("Location", foreign_keys=[current_location_id]) previous_location = relationship("Location", foreign_keys=[previous_location_id])
class Reviews(db.Model): id = db.Column(db.Integer, nullable=False, primary_key=True) asin = db.Column(db.VARCHAR(100)) helpful = db.Column(db.VARCHAR(100)) overall = db.Column(db.Integer) reviewText = db.Column(db.VARCHAR(255)) reviewTime = db.Column(db.Date) reviewerID = db.Column(db.VARCHAR(100)) reviewerName = db.Column(db.VARCHAR(100)) summary = db.Column(db.VARCHAR(255)) unixReviewTime = db.Column(db.Integer) # Initialize w critical information | Others initialize to 0 or respective timing def __init__(self, asin, reviewText, reviewerID, reviewerName, summary): self.asin = asin self.helpful = "[0, 0]" self.overall = 0 self.reviewText = reviewText now = datetime.now() self.reviewTime = now.strftime("%Y-%-m-%-d") self.reviewerID = reviewerID self.reviewerName = reviewerName self.summary = summary self.unixReviewTime = int(now.timestamp()) def json(self): return { 'id': self.id, 'asin': self.asin, 'helpful': self.helpful, 'overall': self.overall, 'reviewText': self.reviewText, 'reviewTime': self.reviewTime, 'reviewerID': self.reviewerID, 'reviewerName': self.reviewerName, 'summary': self.summary, 'unixReviewTime': self.unixReviewTime } @classmethod def find_by_asin(cls, asin): return cls.query.filter_by(asin=asin).all() @classmethod def find_by_id(cls, id): return cls.query.filter_by(id=id).all() def save_to_db(self): db.session.add(self) db.session.commit() def delete_from_db(self): db.session.delete(self) db.session.commit()
class BlacklistModel(db.Model): __tablename__ = 'blacklist' jti = db.Column(db.VARCHAR(36), primary_key=True) time = db.Column(db.TIMESTAMP, nullable=False) @classmethod def check_jti_in_blacklist(cls, query_jti): if cls.query.get(query_jti) is not None: return True else: return False def blacklist_token(self): try: db.session.add(self) db.session.commit() except SQLAlchemyError: db.session.rollback() return ERROR_WRITING_BLACKLIST_TABLE
class UserInfo(db.Model): """ 存储用户信息,根据微信字段 "{"nickName":"我不是大哥","gender":1,"language":"zh_CN","city":"Xinzhou","province":"Shanxi","country":"China","avatarUrl":"https://wx.qlogo.cn/mmopen/vi_32/DYAIOgq83eokAGkics0CTDoLhUsukAmy4sTvb167M3kBKyGfYmBv0tj5InBiahpqhgXBaWic1Bz3OYXC2oYHCzNvg/132"}" """ # 微信的用户openid openid = db.Column(db.VARCHAR(256), primary_key=True) # 昵称 nick_name = db.Column(db.VARCHAR(256), nullable=False) # 用户头像 avatar_url = db.Column(db.VARCHAR(1024), nullable=False) # 性别 gender = db.Column(db.CHAR(2), default="1", nullable=True) # 语言 language = db.Column(db.VARCHAR(64), default="zh_CN", nullable=True) # 城市 city = db.Column(db.VARCHAR(64), default="Xinzhou", nullable=True) # 国籍 country = db.Column(db.VARCHAR(64), default="China", nullable=True) def to_dict(self): d = dict() d['openid'] = self.openid d['nick_name'] = self.nick_name d['avatar_url'] = self.avatar_url d['gender'] = self.gender d['language'] = self.language d['city'] = self.city d['country'] = self.country return d def __init__(self, openid, nick_name, gender, language, city, coutry, avatar_url): self.openid = openid self.nick_name = nick_name self.gender = gender self.language = language self.city = city self.country = coutry self.avatar_url = avatar_url def __repr__(self): return "<UserInfo " + self.nick_name + " " + self.openid + " >"
class ActiveModel(db.Model): __tablename__ = 'active' uid = db.Column(db.VARCHAR(6), primary_key=True) time = db.Column(db.TIMESTAMP, nullable=False) name = db.Column(db.VARCHAR(80), nullable=False) email = db.Column(db.VARCHAR(100), nullable=False, unique=True) password = db.Column(db.VARCHAR(60), nullable=False) views = db.Column(db.BIGINT, nullable=False) likes = db.Column(db.BIGINT, nullable=False) submissions = db.relationship('StoryModel', backref='author', lazy='dynamic') basic = db.relationship('BasicModel', backref='strong', uselist=False) following = db.relationship('FollowModel', foreign_keys='FollowModel.source', backref='followers', lazy='dynamic') followers = db.relationship('FollowModel', foreign_keys='FollowModel.target', backref='following', lazy='dynamic') favourites = db.relationship('LikesModel', foreign_keys='LikesModel.source', backref='fan', lazy='dynamic') viewed = db.relationship('ViewsModel', foreign_keys='ViewsModel.source', backref='viewers', lazy='dynamic') @classmethod def find_entry_by_email(cls, query_email): return cls.query.filter_by(email=query_email).first() @classmethod def find_entry_by_name(cls, query_name, version, current_user): return cls.query.filter(and_(cls.name.ilike(f'%{query_name}%'), cls.uid != current_user, cls.uid != ADMIN_UID))\ .limit(version*15).all() @classmethod def find_entry_by_uid(cls, query_uid): return cls.query.get(query_uid) @classmethod def generate_random_uid(cls): return uuid.uuid4().hex.lower()[0:6] @classmethod def generate_elite_users(cls): return cls.query.filter(cls.uid != ADMIN_UID).order_by( cls.likes.desc()).limit(15).all() @classmethod def add_views_by_one(cls, query_uid): discovered_entry = cls.find_entry_by_uid(query_uid) discovered_entry.views += 1 discovered_entry.create_active_user() @classmethod def add_likes_by_one(cls, query_uid): discovered_entry = cls.find_entry_by_uid(query_uid) discovered_entry.likes += 1 discovered_entry.create_active_user() @classmethod def reduce_likes_by_one(cls, query_uid): discovered_entry = cls.find_entry_by_uid(query_uid) discovered_entry.likes -= 1 discovered_entry.create_active_user() @classmethod def generate_fresh_uid(cls): fresh_uid = cls.generate_random_uid() while cls.find_entry_by_uid(fresh_uid) is not None: fresh_uid = cls.generate_random_uid() return fresh_uid @classmethod def generate_search_data(cls, active_user_list, current_user): active_user_object = cls.find_entry_by_uid(current_user) return [{ 'uid': active_user.uid, 'name': active_user.name, 'image': active_user.basic.image if (active_user.basic and active_user.basic.image != 'no-image') else NO_IMAGE_AVAILABLE, 'already_following': active_user.uid in [ following.target for following in active_user_object.following ] } for active_user in active_user_list] def create_active_user(self): try: db.session.add(self) db.session.commit() except SQLAlchemyError: db.session.rollback() return ERROR_WRITING_ACTIVE_TABLE def delete_active_user(self): try: db.session.delete(self) db.session.commit() except SQLAlchemyError: db.session.rollback()
class NBA(db.Model): __tablename__ = 'nba' id = db.Column(db.Integer, primary_key=True, autoincrement=True) year_time = db.Column(db.VARCHAR(16)) store_time = db.Column(db.VARCHAR(16)) team_info = db.Column(db.Text)
class InactiveModel(db.Model): __tablename__ = 'inactive' email = db.Column(db.VARCHAR(100), primary_key=True) time = db.Column(db.TIMESTAMP, nullable=False) name = db.Column(db.VARCHAR(80), nullable=False) password = db.Column(db.VARCHAR(60), nullable=False) code = db.Column(db.VARCHAR(64), nullable=False, unique=True) # Please use this convention of saying query_email or any other parameter instead of # only writing email. @classmethod def find_entry_by_email(cls, query_email): return cls.query.get(query_email) @classmethod def send_email(cls, inactive_user_object): verification_code = cls.generate_fresh_code() message = { 'personalizations': [{ 'to': [{ 'email': inactive_user_object.email }], 'dynamic_template_data': { 'data': { 'link': f'https://www.themilkyway.ml/confirm/{verification_code}', 'name': inactive_user_object.name.split()[0] } } }], 'from': { 'email': '*****@*****.**', 'name': 'New Account Confirmation' }, 'template_id': 'Here goes the template id!' } sg = SendGridAPIClient( os.getenv('EMAIL_API_KEY', 'Here goes the default API Key!')) response = sg.send(message) if response.status_code == 202: return {'code': verification_code} @classmethod def generate_random_code(cls): return uuid.uuid4().hex.lower() + uuid.uuid4().hex.lower() @classmethod def generate_fresh_code(cls): fresh_code = cls.generate_random_code() while cls.find_entry_by_code(fresh_code) is not None: fresh_code = cls.generate_random_code() return fresh_code @classmethod def find_entry_by_code(cls, query_code): return cls.query.filter_by(code=query_code).first() def create_inactive_user(self): try: db.session.add(self) db.session.commit() except SQLAlchemyError: db.session.rollback() return ERROR_WRITING_INACTIVE_TABLE def delete_inactive_user(self): try: db.session.delete(self) db.session.commit() except SQLAlchemyError: db.session.rollback() return ERROR_DELETING_INACTIVE_TABLE
class TrialsModel(db.Model): __tablename__ = 'trials' TrialID = db.Column(db.VARCHAR(255), nullable=False, primary_key=True) Primary_Register_text = db.Column(db.TEXT(255)) Inclusion_agemin = db.Column(db.VARCHAR(255)) Inclusion_agemax = db.Column(db.VARCHAR(255)) Inclusion_sex = db.Column(db.VARCHAR(255)) URL = db.Column(db.VARCHAR(255)) Study_type = db.Column(db.VARCHAR(255)) Acronym = db.Column(db.VARCHAR(255)) Date_enrollement = db.Column(db.VARCHAR(255)) Phase = db.Column(db.VARCHAR(255)) child_flag = db.Column(db.VARCHAR(255)) Country = db.Column(db.VARCHAR(255)) Date_registration = db.Column(db.VARCHAR(255)) lang = db.Column(db.VARCHAR(10)) Primary_sponsor = db.Column(db.TEXT) Secondary_Sponsor = db.Column(db.TEXT) Public_title = db.Column(db.TEXT) Scientific_title = db.Column(db.TEXT) Study_design = db.Column(db.TEXT) Target_size = db.Column(db.TEXT) Recruitment_status = db.Column(db.TEXT) Contacts = db.Column(db.TEXT) Inclusion_criteria = db.Column(db.TEXT) Exclusion_criteria = db.Column(db.TEXT) Health_condition = db.Column(db.TEXT) Intervention = db.Column(db.TEXT) Primary_outcome = db.Column(db.TEXT) Secondary_outcome = db.Column(db.TEXT) Secondary_IDs = db.Column(db.TEXT) Source_support = db.Column(db.TEXT) def json(self): return { '0. Trial ID': self.TrialID, '1. Public Title': self.Public_title, '2. Scientific Title': self.Scientific_title, '3. Inclusion Criteria': self.Inclusion_criteria, '4. Exclusion Criteria': self.Exclusion_criteria, '5. Health Condition': self.Health_condition, '6. Intervention': self.Intervention, '7. Primary Outcome': self.Primary_outcome, '8. Secondary Outcome': self.Secondary_outcome } @staticmethod def get_by_id(trial_id): found = db.session.query(TrialsModel).filter( TrialsModel.TrialID == trial_id).first() if found: return found.json() else: return None
class FollowModel(db.Model): __tablename__ = 'follow' sno = db.Column(db.INTEGER, autoincrement=True, primary_key=True) source = db.Column(db.VARCHAR(6), db.ForeignKey('active.uid'), nullable=False) target = db.Column(db.VARCHAR(6), db.ForeignKey('active.uid'), nullable=False) time = db.Column(db.TIMESTAMP, nullable=False) @classmethod def generate_following_profile_data(cls, active_user_object): if active_user_object.basic is not None: if active_user_object.basic.private: return {'message': IS_PRIVATE} if active_user_object.basic is None: return [ { 'uid': following.target, 'name': following.following.name, 'image': following.following.basic.image if (following.following.basic and following.following.basic.image != 'no-image') else NO_IMAGE_AVAILABLE } for following in active_user_object.following] @classmethod def force_generate_following_profile_data(cls, active_user_object): return [ { 'uid': following.target, 'name': following.following.name, 'image': following.following.basic.image if (following.following.basic and following.following.basic.image != 'no-image') else NO_IMAGE_AVAILABLE } for following in active_user_object.following ] @classmethod def generate_followers_profile_data(cls, active_user_object): return [ { 'uid': followers.source, 'name': followers.followers.name, 'image': followers.followers.basic.image if (followers.followers.basic and followers.followers.basic.image != 'no-image') else NO_IMAGE_AVAILABLE } for followers in active_user_object.followers ] def create_entry(self): try: db.session.add(self) db.session.commit() except SQLAlchemyError: db.session.rollback() return ERROR_WRITING_FOLLOW_TABLE def delete_entry(self): try: db.session.delete(self) db.session.commit() except SQLAlchemyError: db.session.rollback() return ERROR_DELETING_FOLLOW_TABLE
class BasicModel(db.Model): __tablename__ = 'basic' sno = db.Column(db.INTEGER, autoincrement=True, primary_key=True) uid = db.Column(db.VARCHAR(6), db.ForeignKey('active.uid'), nullable=False) dob = db.Column(db.DATE, nullable=False) bio = db.Column(db.VARCHAR(500), nullable=False) country = db.Column(db.VARCHAR(20), nullable=False) profession = db.Column(db.VARCHAR(20), nullable=False) image = db.Column(db.VARCHAR(100), nullable=False) private = db.Column(db.BOOLEAN, nullable=False) preferences = db.Column(db.VARCHAR(100), nullable=False) @classmethod def generate_basic_profile_data(cls, active_user_object): if active_user_object.basic is None: return { 'message': 'No data', 'name': active_user_object.name, 'image': NO_IMAGE_AVAILABLE } elif active_user_object.basic.private: return { 'message': IS_PRIVATE, 'name': active_user_object.name, 'image': active_user_object.basic.image if active_user_object.basic.image != 'no-image' else NO_IMAGE_AVAILABLE } return { 'bio': active_user_object.basic.bio, 'country': active_user_object.basic.country, 'email': active_user_object.basic.strong.email, 'profession': active_user_object.basic.profession, 'dob': str(active_user_object.basic.dob), 'private': active_user_object.basic.private, 'preferences': active_user_object.basic.preferences, 'image': active_user_object.basic.image if active_user_object.basic.image != 'no-image' else NO_IMAGE_AVAILABLE, 'name': active_user_object.name, } @classmethod def force_generate_basic_profile_data(cls, active_user_object): if active_user_object.basic is None: return { 'message': 'No data', 'name': active_user_object.name, 'image': NO_IMAGE_AVAILABLE } return { 'bio': active_user_object.basic.bio, 'country': active_user_object.basic.country, 'email': active_user_object.email, 'name': active_user_object.name, 'private': active_user_object.basic.private, 'preferences': active_user_object.basic.preferences, 'image': active_user_object.basic.image if active_user_object.basic.image != 'no-image' else NO_IMAGE_AVAILABLE, 'profession': active_user_object.basic.profession, 'dob': str(active_user_object.basic.dob), } def create_entry(self): try: db.session.add(self) db.session.commit() except SQLAlchemyError: db.session.rollback() return ERROR_WRITING_BASIC_TABLE
class StoryModel(db.Model): __tablename__ = 'stories' sid = db.Column(db.VARCHAR(8), primary_key=True) uid = db.Column(db.VARCHAR(6), db.ForeignKey('active.uid')) status = db.Column(db.VARCHAR(10), nullable=False) time = db.Column(db.TIMESTAMP, nullable=False) title = db.Column(db.TEXT, nullable=False) summary = db.Column(db.TEXT, nullable=False) story = db.Column(db.TEXT, nullable=False) views = db.Column(db.BIGINT, nullable=False) likes = db.Column(db.BIGINT, nullable=False) genre = db.Column(db.VARCHAR(75), nullable=False) fans = db.relationship('LikesModel', foreign_keys='LikesModel.target', backref='liked', lazy='dynamic') viewers = db.relationship('ViewsModel', foreign_keys='ViewsModel.target', backref='viewed', lazy='dynamic') @classmethod def find_entry_by_sid(cls, query_sid): return cls.query.get(query_sid) @classmethod def find_entry_by_uid(cls, query_uid): return cls.query.filter_by(uid=query_uid).first() @classmethod def generate_random_sid(cls): return uuid.uuid4().hex.lower()[0:8] @classmethod def generate_fresh_sid(cls): fresh_sid = cls.generate_random_sid() while cls.find_entry_by_sid(fresh_sid) is not None: fresh_sid = cls.generate_random_sid() return fresh_sid @classmethod def find_story_by_sid(cls, query_sid): return cls.query.filter_by(sid=query_sid).first() @classmethod def find_stories_by_genre(cls, query_genre, version): return cls.query.filter(and_(cls.genre.like(f'%{query_genre}%'), cls.status == 'approved'))\ .limit(version*15).all() @classmethod def find_feed_stories_by_genre(cls, query_genre, version): return cls.query.filter(and_(cls.genre.like(f'%{query_genre}%'), cls.status == 'approved'))\ .order_by(cls.time.desc()).limit(version*5).all() @classmethod def find_stories_by_title(cls, query_title, version): return cls.query.filter(and_(cls.title.ilike(f'%{query_title}%'), cls.status == 'approved'))\ .limit(version*15).all() @classmethod def find_latest_story_by_uid(cls, query_uid): return cls.query.filter( and_(cls.uid == query_uid, cls.status == 'approved')).order_by(cls.time.desc()).first() @classmethod def force_find_latest_story_by_uid(cls, query_uid): return cls.query.filter(cls.uid == query_uid).order_by( cls.time.desc()).first() @classmethod def check_story_status(cls, story_object): return story_object.status == 'approved' @classmethod def filter_story_object_list(cls, story_object_list): return filter(StoryModel.check_story_status, story_object_list) @classmethod def words_counter(cls, string): count = 0 l1 = string.split('*/para/**/newline/*') l2 = [i.split("*/para/*") for i in l1] l3 = [[f.split() for f in a] for a in l2] for a in l3: for b in a: for c in b: count += 1 return count @classmethod def generate_story_element_data(cls, story_object): return { 'uid': story_object.uid, 'sid': story_object.sid, 'title': story_object.title, 'name': story_object.author.name, 'summary': story_object.summary, } @classmethod def generate_feed_element_data(cls, story_object): return { 'uid': story_object.uid, 'sid': story_object.sid, 'title': story_object.title, 'name': story_object.author.name, 'summary': story_object.summary, 'time': str(story_object.time), 'views': story_object.views, 'likes': story_object.likes, 'genre': story_object.genre, 'image': story_object.author.basic.image if (story_object.author.basic and story_object.author.basic.image is not 'no-image') else NO_IMAGE_AVAILABLE } @classmethod def add_views_by_one(cls, query_sid): discovered_entry = cls.find_story_by_sid(query_sid) discovered_entry.views += 1 discovered_entry.create_story() @classmethod def add_likes_by_one(cls, query_sid): discovered_entry = cls.find_story_by_sid(query_sid) discovered_entry.likes += 1 discovered_entry.create_story() @classmethod def reduce_likes_by_one(cls, query_sid): discovered_entry = cls.find_story_by_sid(query_sid) discovered_entry.likes -= 1 discovered_entry.create_story() def create_story(self): try: db.session.add(self) db.session.commit() except SQLAlchemyError: db.session.rollback() return ERROR_WRITING_STORY_TABLE def delete_story(self): try: db.session.delete(self) db.session.commit() except SQLAlchemyError: db.session.rollback() return ERROR_DELETING_STORY_TABLE
class Location(db.Model): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.VARCHAR(length=255), nullable=False) world_id = db.Column(db.Integer, db.ForeignKey(World.id), nullable=False) world = relationship("World")
class World(db.Model): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.VARCHAR(length=255), nullable=False)
class Actor(db.Model, UserMixin): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.VARCHAR(length=255), nullable=False) role = db.Column(db.VARCHAR(length=255), nullable=False) password = db.Column(db.VARCHAR(length=255), nullable=False)