class BookVolume(db.Model):
''' 书籍卷节信息 '''
__table_args__ = {'mysql_engine': 'InnoDB', 'mysql_charset': 'utf8'}
id = db.Column(db.Integer(), primary_key=True) # ID
book_id = db.Column(db.Integer(), index=True) # 书籍ID
volume_id = db.Column(db.Integer(), index=True) # 卷ID
volume_name = db.Column(db.String(100)) # 卷名
create_time = db.Column(db.DateTime, default=datetime.now()) # 创建时间（第三方）
chapter_count = db.Column(db.Integer, default=0) # 卷字数
update_time = db.Column(db.DateTime, default=datetime.now()) # 更新时间（第三方）
created = db.Column(db.DateTime, server_default=func.now()) # 创建时间
def __init__(self, data):
self.book_id = int(data['book_id'])
self.volume_id = int(data['volume_id'])
self.volume_name = data['volume_name']
now = datetime.now()
self.create_time = data.get('create_time', now)
self.chapter_count = int(data.get('chapter_count', 0))
self.update_time = data.get('update_time', now)
def update(self, data):
self.volume_name = data['volume_name']
self.create_time = data['create_time']
self.chapter_count = int(data['chapter_count'])
self.update_time = data['update_time']
def to_dict(self):
return dict(
book_id = self.book_id,
volume_id = self.volume_id,
volume_name = self.volume_name,
chapter_count = self.chapter_count
)
class BookCategory(db.Model):
''' 书籍分类信息 '''
__table_args__ = {'mysql_engine': 'InnoDB', 'mysql_charset': 'utf8'}
cate_id = db.Column(db.Integer(), primary_key=True) # 分类ID
cate_name = db.Column(db.String(50)) # 分类名称
parent_id = db.Column(db.Integer(), server_default='-1') # 上级ID 1:男生, 2:出版, 3:女生
showed = db.Column(db.Boolean(), server_default='1')
icon = db.Column(db.String(100))
created = db.Column(db.DateTime, server_default=func.now()) # 创建时间
def __init__(self, cate_name, parent_id=-1):
self.cate_name = cate_name
self.parent_id = parent_id
def to_dict(self):
return dict(
cate_id = self.cate_id,
cate_name = self.cate_name,
parent_id = self.parent_id,
created = self.created.strftime('%Y-%m-%d %H:%M:%S')
)
def to_admin_dict(self):
return dict(
cate_id = self.cate_id,
showed = 1 if self.showed else 0,
cate_name = self.cate_name,
parent_id = self.parent_id,
icon = self.icon if self.icon else '',
created = self.created.strftime('%Y-%m-%d %H:%M:%S')
)
class BuyRankings(db.Model):
""" 购买排行(用于书籍排行) """
__table_args__ = {'mysql_engine': 'InnoDB', 'mysql_charset': 'utf8'}
id = db.Column(db.Integer(), primary_key=True) # ID
book_id = db.Column(db.Integer(), index=True) # 书籍ID
book_name = db.Column(db.String(100)) # 书籍名称
channel_type = db.Column(db.SmallInteger(), index=True) #1男2女
author_name = db.Column(db.String(50))#作者
is_publish = db.Column(db.Integer()) # 是否出版（1：是；2：否）
status = db.Column(db.Integer())# 连载状态（1：已完结；2：未完结）
created = db.Column(db.DateTime) # 创建时间
buy_num = db.Column(db.Integer()) #购买次数
book_time = db.Column(db.DateTime) # 创建时间
def __init__(self, book_id, channel_type, author_name, is_publish, status, created, buy_num, book_name, book_time):
self.book_id = book_id
self.channel_type = channel_type
self.author_name = author_name
self.is_publish = is_publish
self.status = status
self.created = created
self.buy_num = buy_num
self.book_name = book_name
self.book_time = book_time
class PurchasedBook(db.Model):
"""已购买书籍信息"""
__table_args__ = {'mysql_engine': 'InnoDB', 'mysql_charset': 'utf8'}
id = db.Column(db.Integer(), primary_key=True) # ID
user_id = db.Column(db.Integer(), index=True) # 用户id
book_id = db.Column(db.Integer(), index=True) # 书籍ID
buy_info = db.Column(db.Text(), default='{}') # 已购买章节 {'卷id':[章节id,...]}
auto_buy = db.Column(db.Boolean, default=False) # 是否自动购买下一章
created = db.Column(db.DateTime, server_default=func.now()) # 创建时间
db.UniqueConstraint('user_id', 'book_id')
class TaobaoToken(db.Model):
__tablename__ = 'core_taobao_token'
id = db.Column(db.Integer(), primary_key=True)
user_id = db.Column(db.Integer())
taobao_id = db.Column(db.Integer())
screen_name = db.Column(db.VARCHAR(64))
open_uid = db.Column(db.VARCHAR(64))
isv_uid = db.Column(db.VARCHAR(64))
def __repr__(self):
return "<Taobao User Name %r>" % self.screen_name
class BookChapters(db.Model):
''' 书籍章节信息 '''
__table_args__ = {'mysql_engine': 'InnoDB', 'mysql_charset': 'utf8'}
id = db.Column(db.Integer(), primary_key=True) # ID
book_id = db.Column(db.Integer(), index=True) # 书籍ID
volume_id = db.Column(db.Integer(), index=True) # 卷ID
chapter_id = db.Column(db.Integer(), index=True) # 章节ID
chapter_name = db.Column(db.String(100)) # 章节名称
word_count = db.Column(db.Integer) # 字数
content_url = db.Column(db.String(300), server_default='') # 章节内容url 仅外链小说用到
# add by [email protected] 2017-9-12
money = db.Column(db.Integer, server_default='0') # 分/千字
create_time = db.Column(db.DateTime) # 创建时间（第三方）
update_time = db.Column(db.DateTime) # 更新时间（第三方）
free_source = db.Column(db.String(50), server_default='', index=True) # 外链 源名
created = db.Column(db.DateTime, server_default=func.now()) # 创建时间
def __init__(self, data):
self.book_id = int(data['book_id'])
self.volume_id = int(data['volume_id'])
self.chapter_id = int(data['chapter_id'])
self.chapter_name = data['chapter_name']
self.word_count = int(data['word_count'])
self.create_time = data['create_time']
self.update_time = data['update_time']
def to_dict(self):
return dict(
book_id = self.book_id,
volume_id = self.volume_id,
chapter_id = self.chapter_id,
chapter_name = self.chapter_name,
word_count = self.word_count,
content_url = self.content_url,
)
def to_admin_dict(self):
return dict(
id = self.id,
book_id = self.book_id,
volume_id = self.volume_id,
chapter_id = self.chapter_id,
chapter_name = self.chapter_name,
word_count = self.word_count,
money = self.money
)
class Client(db.Model):
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(), nullable=False)
last_name = db.Column(db.String(), nullable=False)
gender = db.Column(db.String(), nullable=False)
country = db.Column(db.String(), nullable=False)
dob = db.Column(db.String(), nullable=False)
phone_no = db.Column(db.Integer(), nullable=False)
criminal_record = db.Column(db.Boolean, default=False)
ssn = db.Column(db.Integer(), nullable=False)
date_registered = db.Column(db.DateTime,
nullable=False,
default=datetime.now)
agent_id = db.Column(db.Integer, db.ForeignKey('agent.id'))
apartment_id = db.Column(db.Integer, db.ForeignKey('apartment.id'))
class HotWords(BaseModel, TimestampMixin):
__tablename__ = 'hot_words'
id = db.Column(db.Integer(), primary_key=True)
word = db.Column(db.VARCHAR(255))
def __init__(self, **kwargs):
self.word = kwargs.pop('word', None)
class ChannelBookCategory(db.Model):
''' 渠道书籍分类信息 '''
__table_args__ = {'mysql_engine': 'InnoDB', 'mysql_charset': 'utf8'}
channel_cate_id = db.Column(db.String(20), primary_key=True) # 分类ID（第三方）
cate_id = db.Column(db.Integer(), index=True) # 分类ID
def __init__(self, channel_cate_id, cate_id):
self.channel_cate_id = channel_cate_id
self.cate_id = cate_id
class User(db.Model):
__tablename__ = "core_gkuser"
id = db.Column(db.Integer(), primary_key=True)
password = db.Column(db.VARCHAR(128))
last_login = db.Column(db.DateTime())
is_superuser = db.Column(db.Boolean())
email = db.Column(db.VARCHAR(255))
def __repr__(self):
return "<User e-Mail %r>" % self.email
class Agent(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(), nullable=False)
last_name = db.Column(db.String(), nullable=False)
password = db.Column(db.String(120), nullable=False)
country = db.Column(db.String(), nullable=False)
email = db.Column(db.String(), nullable=False, unique=True)
phone_no = db.Column(db.String(), nullable=False)
gender = db.Column(db.String(), nullable=False)
date_uploaded = db.Column(db.DateTime,
nullable=False,
default=datetime.now)
date_registered = db.Column(db.DateTime,
nullable=False,
default=datetime.now)
agent_image_file = db.Column(db.String(20), nullable=False)
agent_photo_data = db.Column(db.LargeBinary)
amount_earned = db.Column(db.Integer(), default=0)
buildings_sold = db.Column(db.Integer(), default=0)
location = db.Column(db.String())
client = db.relationship('Client', backref='real_estate', lazy=True)
apartment = db.relationship('Apartment', backref='broker', lazy=True)
facebook_name = db.Column(db.String())
twitter_name = db.Column(db.String())
confirmed = db.Column(db.Boolean, nullable=False, default=False)
def get_reset_token(self, expires_sec=1800):
s = Serializer(app.config['SECRET_KEY'], expires_sec)
return s.dumps({'agent_id': self.id}).decode('utf-8')
@staticmethod
def verify_reset_token(token):
s = Serializer(app.config['SECRET_KEY'])
try:
agent_id = s.loads(token)['agent_id']
except ValueError:
return None
return Agent.query.get(agent_id)
def __repr__(self):
return f"User('{self.first_name}', '{self.email}', '{self.confirmed}')"
class Image(db.Model):
id = db.Column(db.Integer(), primary_key=True)
filename = db.Column(db.String(120))
url = db.Column(db.String(120))
created = db.Column(db.DateTime(), server_default=func.now())
def __init__(self, filename):
self.filename = self.get_filename(filename)
def get_filename(self, filename):
tmp = filename.rsplit('.', 1)
return tmp[0] + '_%s_%s.%s' % (int(
time.time()), random.randint(10000, 99999), tmp[1])
class SearchHistory(BaseModel, TimestampMixin):
__tablename__ = 'search_history'
id = db.Column(db.Integer(), primary_key=True)
user_id = db.Column(db.Integer(), index=True)
result_count = db.Column(db.Integer(), default=0)
keyword = db.Column(db.VARCHAR(255))
ip = db.Column(IPAddressType)
user_agent = db.Column(db.VARCHAR(255))
# def __repr__(self):
# return "<Keyword: {0} from IP {1}>".format(self.keyword, self.ip)
def __init__(self, *args, **kwargs):
self.user_id = kwargs.pop('user_id', None)
# assert self.user_id is not None
self.keyword = kwargs.pop('keyword', None)
self.ip = kwargs.pop('ip', None)
self.user_agent = kwargs.pop('user_agent', None)
self.result_count = kwargs.pop('result_count', 0)
class FreeBook(db.Model):
"""外链书籍基本信息"""
__table_args__ = {'mysql_engine': 'InnoDB', 'mysql_charset': 'utf8'}
id = db.Column(db.Integer(), primary_key=True)
book_id = db.Column(db.Integer(), index=True) # 书籍ID
channel_book_id = db.Column(db.String(20), unique=True) # 渠道书籍id 渠道名:书籍id
chapter_num = db.Column(db.Integer()) # 章节数量
status = db.Column(db.Integer()) # 连载状态（1：已完结；2：未完结）
create_time = db.Column(db.DateTime) # 创建时间（第三方）
word_count = db.Column(db.Integer) # 字数
update_time = db.Column(db.DateTime) # 更新时间
showed = db.Column(db.Boolean(), server_default='0')
free_source = db.Column(db.String(50), server_default='', index=True) # 来源
channel_cate = db.Column(db.String(50), server_default='') # 渠道方分类名
last_chapter_name = db.Column(db.String(100), server_default='') # 最新章节名
created = db.Column(db.DateTime, server_default=func.now()) # 创建时间
def get_parse_rule(self):
"""获取解析规则"""
if self.free_source == 'wudu':
return '吾读', '//*[@id="acontent"]/text()'
elif self.free_source == 'dushu88':
return '88读书', '//*[@id="nr1"]/text()'
elif self.free_source == 'kanshu':
return '看书', '//*[@id="chapcont"]/text()'
return '', ''
def to_dict(self):
source_name, parse_rule = self.get_parse_rule()
return dict(chapter_num=self.chapter_num,
status=self.status,
create_time=self.create_time.strftime('%Y-%m-%d %H:%M:%S'),
word_count=self.word_count,
update_time=self.update_time.strftime('%Y-%m-%d %H:%M:%S'),
free_source=self.free_source,
source=source_name,
parse_rule=parse_rule,
created=self.created.strftime('%Y-%m-%d %H:%M:%S'))
class Article(db.Model):
__tablename__ = "core_article"
__bind_key__ = 'article'
# (remove, draft, published) = xrange(3)
# ARTICLE_STATUS_CHOICES = [
# (published, _("published")),
# (draft, _("draft")),
# (remove, _("remove")),
# ]
# ARTICLE_STATUS_CHOICES = ("remove", "draft","published")
id = db.Column(db.Integer(), primary_key=True)
creator_id = db.Column(db.Integer())
title = db.Column(db.VARCHAR(255))
# identity_code = db.Column(db.VARCHAR(255))
cover = db.Column(db.VARCHAR(255))
# publish = db.Column(db.Enum, ARTICLE_STATUS_CHOICES)
content = db.Column(db.Text())
created_datetime = db.Column(db.DateTime())
updated_datetime = db.Column(db.DateTime())
showcover = db.Column(db.Boolean(), default=False)
read_count = db.Column(db.Integer(), default=0)
feed_read_count = db.Column(db.Integer(), default=0)
def __repr__(self):
return "<Article %r>" % self.title
@property
def strip_content(self):
html_string = self.content.strip()
html_string = html_string.strip('\n')
res = []
parser = HTMLParser()
parser.handle_data = res.append
parser.feed(html_string)
parser.close()
content_string = ''.join(res)
return content_string.encode('utf-8')
class UserModel(TrackingModel):
__table_args__ = dict(schema=config.SCHEMA_NAME, extend_existing=True)
__tablename__ = "user"
_id = db.Column(UUID, primary_key=True)
is_activate = db.Column(db.Boolean())
status = db.Column(db.Integer())
username = db.Column(db.String(255))
password = db.Column(db.String(1023))
fullname = db.Column(db.String(255))
gender = db.Column(db.Integer())
year_of_birth = db.Column(db.Integer())
contact__phone = db.Column(db.String(15))
contact__email = db.Column(db.String(255))
is_verified__phone = db.Column(db.Boolean())
is_verified__email = db.Column(db.Boolean())
followers = db.Column(ARRAY(UUID), default=[])
_etag = db.Column(db.String(255))
class BookShelfName(db.Model):
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(100))
nickname = db.Column(db.String(100))
updated = db.Column(db.DateTime, server_default=func.now())
created = db.Column(db.DateTime, server_default=func.now())
def __init__(self, name, nickname):
self.name = name
self.nickname = nickname
def to_admin_dict(self):
return dict(id=self.id,
name=self.name,
nickname=self.nickname,
created=self.created.strftime('%Y-%m-%d %H:%M:%S'),
updated=self.updated.strftime('%Y-%m-%d %H:%M:%S'))
class AdminUser(UserMixin, db.Model):
"""后台用户"""
id = db.Column(db.Integer(), primary_key=True)
email = db.Column(db.String(20))
password = db.Column(db.String(128))
created = db.Column(db.DateTime(), server_default=func.now())
group_id = db.Column(db.Integer, server_default='-1')
def __init__(self, email, password, group_id):
self.email = email
self.password = password
self.group_id = group_id
def to_admin_dict(self):
group = AdminUserGroup.query.filter_by(id=self.group_id).first()
group_name = group.name if group else self.group_id
return dict(id=self.id,
email=self.email,
group_id=group_name,
created=self.created.strftime('%Y-%m-%d %H:%M:%S'))
class BookChapterContent(db.Model):
''' 书籍章节内容信息 '''
__table_args__ = {'mysql_engine': 'InnoDB', 'mysql_charset': 'utf8'}
id = db.Column(db.Integer(), primary_key=True) # ID
book_id = db.Column(db.Integer) # 书籍ID
volume_id = db.Column(db.Integer) # 卷ID
chapter_id = db.Column(db.Integer) # 章节ID
content = db.Column(MEDIUMTEXT) # 章节内容
created = db.Column(db.DateTime, server_default=func.now()) # 创建时间
db.Index('ix_book_id_chapter_id', book_id, chapter_id)
def __init__(self, data):
self.book_id = int(data['book_id'])
self.volume_id = int(data['volume_id'])
self.chapter_id = int(data['chapter_id'])
self.content = data['content'].replace(u' ', '').replace(' ', '')
def update(self, data):
self.content = data['content'].replace(u' ', '').replace(' ', '')
class BookMark(db.Model):
''' 书签 '''
__table_args__ = {'mysql_engine': 'InnoDB', 'mysql_charset': 'utf8'}
id = db.Column(db.Integer(), primary_key=True) # ID
user_id = db.Column(db.Integer) # 用户id
book_id = db.Column(db.Integer) # 书籍ID
volume_id = db.Column(db.Integer) # 卷ID
chapter_id = db.Column(db.Integer) # 章节ID
params = db.Column(db.String(100)) #客户端字段
created = db.Column(db.DateTime, server_default=func.now()) # 创建时间
def to_dict(self):
return dict(
id = self.id,
user_id = self.user_id,
book_id = self.book_id,
volume_id = self.volume_id,
chapter_id = self.chapter_id,
created = self.created,
params = self.params
)
class BookShelf(db.Model):
''' 书架 '''
__table_args__ = {'mysql_engine': 'InnoDB', 'mysql_charset': 'utf8'}
id = db.Column(db.Integer(), primary_key=True)
book_id = db.Column(db.Integer(), index=True) # 书籍ID
name = db.Column(
db.String(100)) # 书架名称('myself', 'hot', 'new', 'recommend', 'finish')
user_id = db.Column(db.Integer()) # 用户id, 用于myself 自己的书架
ranking = db.Column(db.Integer(), default=0) # 用于排序
rate = db.Column(db.Integer(), default=0) # 阅读进度(百分率分子)
showed = db.Column(db.Boolean(), default=True) # 是否显示
sex = db.Column(db.Integer(), server_default='0') # 热门和新书需要区分男女频（1：男；2: 女)
created = db.Column(db.DateTime, server_default=func.now()) # 创建时间
updated = db.Column(db.DateTime, server_default=func.now()) # 更新时间
db.Index('ix_book_id_name_user_id', book_id, name, user_id, unique=True)
def __init__(self, book_id, name, user_id, ranking, rate, showed, sex):
self.book_id = book_id
self.name = name
self.user_id = user_id
self.ranking = ranking
self.rate = rate
self.showed = showed
self.sex = sex
def to_admin_dict(self):
book = Book.query.filter_by(book_id=self.book_id).first()
return dict(id=self.id,
book_id=self.book_id,
book=book.to_admin_dict() if book else {},
name=self.name,
user_id=self.name,
ranking=self.ranking,
rate=self.rate,
showed=int(self.showed) if self.showed else 0,
sex=self.sex,
created=self.created.strftime('%Y-%m-%d %H:%M:%S'))
class User(UserMixin, db.Model):
""" 用户表 """
id = db.Column(db.Integer(), primary_key=True)
phone = db.Column(db.String(20), unique=True)
password = db.Column(db.String(128))
nickname = db.Column(db.String(50))
email = db.Column(db.String(20))
notify_phone = db.Column(db.String(20)) # 接收通知的手机号码, 可以和phone 不一致
level = db.Column(db.Integer(), default=0)
avatar = db.Column(db.String(200))
sex = db.Column(db.Integer(), server_default='0')#1男2女
platform = db.Column(db.String(20))
device_id = db.Column(db.String(40), index=True, unique=True) # 设备id 安卓:mac ios:idfa
register_ip = db.Column(db.String(20))
intro = db.Column(db.String(300)) # 个人简介
aphorism = db.Column(db.String(200)) # 个人签名
oauth_from = db.Column(db.String(20), server_default='') # 认证来源 tel_pwd, weibo, wechat, qq
oauth_openid = db.Column(db.String(128)) # openid， 对于微信， 是unionid（用openid 会导致公众号和手机客户端不一致）
oauth_userinfo = db.Column(db.Text) # 来自第三方平台的用户额外信息
oauth_time = db.Column(db.DateTime()) # 绑定第三方帐号时间
oauth_nickname = db.Column(db.String(50))
oauth_avatar = db.Column(db.String(200))
modified = db.Column(db.DateTime(), server_default=func.now())
created = db.Column(db.DateTime(), server_default=func.now())
def to_admin_dict(self):
ub = UserBalance.query.filter_by(user_id=self.id).first()
balance = ub.balance if ub else 0
nickname = self.nickname if self.nickname else ''
if self.oauth_from == 'tel_pwd':
if self.phone:
nickname = '%s****%s' %(self.phone[:3], self.phone[-4:])
sex = u'男' if self.sex == 1 else u'女'
return dict(
id = self.id,
phone = self.phone if self.phone else '',
nickname = nickname,
email = self.email if self.email else '',
notify_phone = self.notify_phone if self.notify_phone else '',
level = self.level if self.level else '',
avatar = self.avatar if self.avatar else 'http://ov2eyt2uw.bkt.clouddn.com/android_pre.jpg',
platform = self.platform if self.platform else '',
register_ip = self.register_ip,
intro = self.intro if self.intro else '',
aphorism = self.aphorism if self.aphorism else '',
oauth_from = self.oauth_from if self.oauth_from else '',
oauth_userinfo = json.loads(self.oauth_userinfo) if self.oauth_userinfo else '',
balance = balance,
sex = sex,
channel_name = self.get_channel_name(),
created = self.created.strftime('%Y-%m-%d %H:%M:%S')
)
def to_dict(self):
return dict(
id = self.id,
phone = self.phone if self.phone else '',
nickname = self.nickname if self.nickname else self.id,
avatar = self.avatar or 'http://ov2eyt2uw.bkt.clouddn.com/default_avatar.png',
intro = self.intro if self.intro else '',
aphorism = self.aphorism if self.aphorism else '',
notify_phone = self.notify_phone if self.notify_phone else '',
oauth_openid = self.oauth_openid if self.oauth_openid else '',
oauth_userinfo = self.oauth_userinfo if self.oauth_userinfo else '',
oauth_from = self.oauth_from if self.oauth_from else '',
oauth_time = self.oauth_time.__str__() if self.oauth_time else '',
oauth_nickname = self.oauth_nickname or '',
oauth_avatar = self.oauth_avatar or self.avatar or 'http://ov2eyt2uw.bkt.clouddn.com/default_avatar.png',
sex = self.sex
)
class Role(db.Model, RoleMixin):
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(80), unique=True)
description = db.Column(db.String(255))
class Publication(FullText, db.Model):
__tablename__ = 'publication'
__fulltext_columns__ = (
'pub_title',
'pub_authors',
'pub_abstract',
)
__table_args__ = (db.UniqueConstraint('pub_doi',
'pub_pmid',
'pub_pmc',
'pub_arxiv',
'pub_biorxiv',
name='_pub_unique'), )
# Publication information
id = db.Column(db.Integer, primary_key=True)
pub_title = db.Column(db.String(300))
pub_authors = db.Column(db.String(1000))
pub_abstract = db.Column(db.Text())
pub_doi = db.Column(db.String(250))
pub_pmid = db.Column(db.Integer())
pub_pmc = db.Column(db.Integer())
pub_arxiv = db.Column(db.String(25))
pub_biorxiv = db.Column(db.String(250))
pub_biorxiv_url = db.Column(db.String(250))
pub_url = db.Column(db.String(250))
pub_pdf_url = db.Column(db.String(250))
pub_journal = db.Column(db.String(100))
pub_date = db.Column(db.DateTime)
pub_created_on = db.Column(db.DateTime, default=now)
pub_thumbnail = db.Column(db.String(THREAD.MAX_LINK), default=None)
threads = db.relationship('Thread', back_populates='publication')
downloads = db.relationship('Publication_Download',
back_populates='publication')
@property
def download_count(self):
return db.session.query(Publication_Download) \
.filter(Publication_Download.publication_id == self.id) \
.count()
@property
def pub_id(self):
if self.pub_pmid:
return self.pub_pmid
elif self.pub_pmc:
return f"PMC{self.pub_pmc}"
elif self.pub_arxiv:
return f"arxiv-{self.pub_arxiv}"
elif self.pub_biorxiv:
return f"biorxiv-{self.pub_biorxiv}"
else:
return self.pub_doi
@validates('pub_title', 'pub_authors', 'pub_abstract', 'pub_journal')
def truncate(self, key, value):
max_len = getattr(self.__class__, key).prop.columns[0].type.length
if value and max_len:
if len(value) > max_len:
return value[:max_len]
return value
def fetch_abstract(self):
"""
Used to process text within an abstract
"""
if self.pub_abstract:
return linkify(self.pub_abstract)
def fetch_github_links(self):
if self.pub_abstract:
return find_github_links(self.pub_abstract)
def mark_downloaded(self, user_id):
"""
Marks a publication as having been downloaded.
"""
td = Publication_Download(user_id=user_id, publication_id=self.id)
td, exists = get_or_create(Publication_Download,
user_id=user_id,
publication_id=self.id)
def has_downloaded(self, user_id):
"""
Has the user downloaded the PDF?
"""
rs = Publication_Download.query.filter(
db.and_(Publication_Download.user_id == user_id,
Publication_Download.publication_id == self.id))
return True if rs.first() else False
def __repr__(self):
return '<Publication %r>' % (self.pub_title)
class Banner(db.Model):
"""广告表"""
id = db.Column(db.Integer(), primary_key=True)
title = db.Column(db.String(100))
platform = db.Column(db.String(50))
activity = db.Column(db.String(50))
ios_activity = db.Column(db.String(50))
params = db.Column(
db.String(150)) # 客户端需要参数,保存字典,暂时需要{'book_id':111, 'book_name': u''}
sex = db.Column(db.Integer(), default=1) # 0: 所有 1：男；2: 女
url = db.Column(db.String(150))
banner_url = db.Column(db.String(150))
level = db.Column(db.Integer(), default=0)
showed = db.Column(db.Boolean(), default=False)
modified = db.Column(db.DateTime(), server_default=func.now())
created = db.Column(db.DateTime(), server_default=func.now())
m_id = db.Column(db.Integer(), server_default='-1')
def __init__(self, data):
self.title = data.get('title', '')
self.platform = data.get('platform', '')
self.activity = data.get('activity', '')
self.ios_activity = data.get('ios_activity', '')
self.params = json.dumps(json.loads(data.get('params',
json.dumps({}))))
self.sex = int(data.get('sex', 0))
self.url = data.get('url', '')
self.banner_url = data['banner_url']
self.level = int(data.get('level', 0))
self.showed = 1 if int(data.get('showed', 0)) else 0
self.m_id = int(data.get('m_id', -1))
def update(self, data):
print data
self.title = data.get('title', '')
self.platform = data.get('platform', '')
self.activity = data.get('activity', '')
self.ios_activity = data.get('ios_activity', '')
self.params = json.dumps(json.loads(data.get('params',
json.dumps({}))))
self.sex = int(data.get('sex', 0))
self.url = data.get('url', '')
self.banner_url = data['banner_url']
self.level = int(data.get('level', 0))
self.showed = 1 if int(data.get('showed', 0)) else 0
self.m_id = int(data.get('m_id', -1))
self.modified = datetime.now()
def to_admin_dict(self):
return dict(id=self.id,
title=self.title,
platform=self.platform,
activity=self.activity,
ios_activity=self.ios_activity,
params=json.loads(self.params),
sex=self.sex,
url=self.url,
banner_url=self.banner_url,
level=self.level,
showed=int(self.showed),
created=self.created.strftime('%Y-%m-%d %H:%M:%S'),
modified=self.modified.strftime('%Y-%m-%d %H:%M:%S'))
def to_dict(self):
return dict(id=self.id,
title=self.title,
platform=self.platform,
activity=self.activity,
ios_activity=self.ios_activity,
params=json.loads(self.params),
sex=self.sex,
url=self.url,
banner_url=self.banner_url,
level=self.level)
class Book(db.Model):
''' 书籍基本信息 '''
__table_args__ = {'mysql_engine': 'InnoDB', 'mysql_charset': 'utf8'}
book_id = db.Column(db.Integer(), primary_key=True) # 书籍ID
channel_book_id = db.Column(db.String(20), unique=True) # 渠道书籍id 渠道名:书籍id
book_name = db.Column(db.String(100)) # 书籍名称
cate_id = db.Column(db.Integer(), index=True) # 书籍分类ID
channel_type = db.Column(db.SmallInteger(), index=True) # 书籍频道（1：男；2: 女 3: 出版 0: 无此属性默认为0）
author_name = db.Column(db.String(50)) # 作者
chapter_num = db.Column(db.Integer()) # 章节数量
is_publish = db.Column(db.Integer()) # 是否出版（1：是；2：否）
status = db.Column(db.Integer()) # 连载状态（1：已完结；2：未完结）
create_time = db.Column(db.DateTime) # 创建时间（第三方）
cover = db.Column(db.String(300)) # 封面图片（链接）
intro = db.Column(TEXT) # 简介
word_count = db.Column(db.Integer) # 字数
update_time = db.Column(db.DateTime) # 更新时间
created = db.Column(db.DateTime, server_default=func.now()) # 创建时间
# add [email protected] 2017-9-12
showed = db.Column(db.Boolean(), server_default='0')
source = db.Column(db.String(50), server_default='sina') # 来源
free_collect = db.Column(db.Boolean(), server_default='0') # 是否外链小说
channel_cate = db.Column(db.String(50), server_default='') # 渠道方分类名
ranking = db.Column(db.Integer(), server_default='0') #排序
def to_admin_dict(self):
cate = BookCategory.query.filter_by(cate_id=self.cate_id).first()
cate_name = cate.cate_name if cate else str(self.cate_id)
source = ''
if self.source == 'sina':
source = u'新浪阅读'
elif self.source == 'kaixing':
source = u'恺兴阅读'
elif self.source == 'zhangyue':
source = u'掌阅'
elif self.source == 'jingyu':
source = u'鲸鱼阅读'
elif self.source == 'anzhi':
source = u'安之'
elif self.source == 'riyue':
source = u'日月中文网'
else:
source = self.source
return dict(
book_id = self.book_id,
channel_book_id = self.channel_book_id,
book_name = self.book_name,
cate_id = cate_name,
channel_type = self.channel_type,
author_name = self.author_name,
chapter_num = self.chapter_num,
is_publish = self.is_publish,
status = self.status,
create_time = self.create_time.strftime('%Y-%m-%d %H:%M:%S'),
cover = self.cover if self.cover else 'https://ssl.kdyoushu.com/default_free_book_cover.jpg',
intro = self.intro if self.intro else '',
word_count = self.word_count,
update_time = self.update_time.strftime('%Y-%m-%d %H:%M:%S'),
created = self.created.strftime('%Y-%m-%d %H:%M:%S'),
showed = int(self.showed),
source = source)
def __init__(self, data):
self.channel_book_id = data['channel_book_id']
self.book_name = data['book_name']
self.cate_id = int(data['cate_id'])
self.channel_type = int(data['channel_type'])
self.author_name = data['author_name']
self.chapter_num = data['chapter_num']
self.is_publish = data['is_publish']
self.status = data['status']
self.create_time = data['create_time']
self.cover = data['cover']
self.intro = data['intro']
self.word_count = int(data['word_count'])
self.update_time = data['update_time']
self.source = data['source']
self.created = datetime.now()
def update(self, data):
self.book_name = data['book_name']
self.cate_id = int(data['cate_id'])
self.channel_type = int(data['channel_type'])
self.author_name = data['author_name']
self.chapter_num = data['chapter_num']
self.is_publish = data['is_publish']
self.status = data['status']
self.create_time = data['create_time']
self.cover = data['cover']
self.intro = data['intro']
self.word_count = int(data['word_count'])
self.update_time = data['update_time']
self.ranking = data['ranking']
def to_dict(self):
source = ''
if self.source == 'sina':
source = u'新浪阅读'
elif self.source == 'kaixing':
source = u'恺兴阅读'
elif self.source == 'zhangyue':
source = u'掌阅'
elif self.source == 'jingyu':
source = u'鲸鱼阅读'
elif self.source == 'anzhi':
source = u'安之'
else:
source = self.source
return dict(book_id=self.book_id,
book_name=self.book_name,
cate_id=self.cate_id,
channel_type=self.channel_type,
author_name=self.author_name,
chapter_num=self.chapter_num,
is_publish=self.is_publish,
status=self.status,
create_time=self.create_time.strftime('%Y-%m-%d %H:%M:%S'),
cover=self.cover,
intro=self.intro,
word_count=self.word_count,
source=source,
update_time=self.update_time.strftime('%Y-%m-%d %H:%M:%S'),
free_collect=1 if self.free_collect else 0,
created=self.created.strftime('%Y-%m-%d %H:%M:%S'))
