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)
