def fake():
resp = requests.get(
'https://viblo.asia/api/posts/editors-choice?limit=500')
json = resp.json()
data = json.get('data')
list_post = []
for d in data:
new_post = Post(title=d.get('title'),
body=d.get('contents'),
body_html=markdown(d.get('contents')),
date_post=datetime.utcnow(),
author_id=1)
for tag in d.get('tags').get('data'):
tag_target = Tags.query.filter_by(name=tag.get('name')).first()
if tag_target is None:
tag_insert = Tags(name=tag.get('name'),
url_image=tag.get('image'))
db.session.add(tag_insert)
db.session.flush()
new_post.tags.append(tag_insert)
else:
new_post.tags.append(tag_target)
list_post.append(new_post)
print(len(list_post))
db.session.add_all(list_post)
db.session.commit()
class Reply(db.Model):
"""评论"""
__tablename__ = 'reply'
body = db.Column(db.Text)
body_html = db.Column(db.Text)
disabled = db.Column(db.Boolean) # 查禁不当评论
timestamp = db.Column(db.DateTime,
primary_key=True,
index=True,
default=datetime.utcnow())
comment_id = db.Column(db.Integer,
db.ForeignKey('comments.id'),
primary_key=True)
com_author_id = db.Column(db.Integer,
db.ForeignKey('users.id'),
primary_key=True)
reply_id = db.Column(db.Integer,
db.ForeignKey('users.id'),
primary_key=True)
article_id = db.Column(db.Integer, db.ForeignKey('posts.id'))
@staticmethod
def on_changed_body(target, value, oldvalue, initator):
allowed_tags = [
'a', 'abbr', 'acronym', 'b', 'blockquote', 'code', 'em', 'i', 'li',
'ol', 'pre', 'strong', 'ul', 'h1', 'h2', 'h3', 'p'
]
target.body_html = bleach.linkify(
bleach.clean(markdown(value, output_format='html'),
tags=allowed_tags,
strip=True))
class Like(db.Model):
__tablename__ = 'like_table'
post_id = db.Column(db.Integer,
db.ForeignKey('posts.post_id'),
primary_key=True)
user_id = db.Column(db.Integer, primary_key=True)
date_like = db.Column(db.DateTime, default=datetime.utcnow())
class Post(db.Model):
__tablename__ = 'posts'
id = db.Column(db.Integer, primary_key=True)
body = db.Column(db.Text)
title = db.Column(db.String(64))
type = db.Column(db.String(64))
timestamp = db.Column(db.DateTime, index=True, default=datetime.utcnow())
author_id = db.Column(
db.Integer, db.ForeignKey('users.id')) # 相当于在post里有一个.user可以直接拿到User
body_html = db.Column(db.Text)
comments = db.relationship('Comment', backref='comments', lazy='dynamic')
visible = db.Column(db.SmallInteger)
@staticmethod
def generate_fake(num):
for i in range(0, num):
post = Post(body=str(num), author_id=1)
db.session.add(post)
db.session.commit()
@staticmethod
def on_change_body(target, value, oldvalue, initiator):
# allowed_tags = ['a','abbr','acronym','b','blockquote','code','em','i','li','ol','pre','strong'
# ,'ul','h1','h2','h3','p','img']
target.body_html = markdown(
value,
output_format='html',
extensions=[GithubFlavoredMarkdownExtension()])
class Comments(db.Model):
__tablename__ = 'comments'
id = db.Column(db.Integer, primary_key=True)
body = db.Column(db.Text)
body_html = db.Column(db.Text)
date_comment = db.Column(db.DateTime, index=True, default=datetime.utcnow())
disable = db.Column(db.Boolean, default=False)
user_id = db.Column(db.Integer)
post_id = db.Column(db.Integer, db.ForeignKey('posts.post_id'))
user_like = db.relationship('LikeComment', backref='comment', lazy='dynamic', cascade="all, delete-orphan")
def to_json(self, user_comment, user_id):
return {
'comment_id' : self.id,
'body_html': self.body_html,
'date_comment': self.date_comment,
'disable': self.disable,
'post_id': self.post_id,
'user_comment': user_comment,
'number_like': self.user_like.count(),
'is_liked': self.is_liked_comment(user_id)
}
def is_liked_comment(self, user_id):
like_cmt = self.user_like.filter_by(user_id=user_id).first()
if like_cmt is None:
return False
return True
class Follow(db.Model):
__tablename__ = 'follows'
follower_id = db.Column(db.Integer,
db.ForeignKey('users.id'),
primary_key=True)
followed_id = db.Column(db.Integer,
db.ForeignKey('users.id'),
primary_key=True)
timestamp = db.Column(db.DateTime, default=datetime.utcnow())
class Follow(db.Model):
__tablename__ = 'follow'
follower_id = db.Column(db.Integer,
db.ForeignKey('user_details.user_id'),
primary_key=True)
followed_id = db.Column(db.Integer,
db.ForeignKey('user_details.user_id'),
primary_key=True)
date_follow = db.Column(db.DateTime, default=datetime.utcnow())
class Post(db.Model):
__tablename__ = 'posts'
post_id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.Text)
body = db.Column(db.Text)
body_html = db.Column(db.Text)
date_post = db.Column(db.DateTime, index=True, default=datetime.utcnow())
author_id = db.Column(db.Integer)
comments = db.relationship('Comments', backref='post', lazy='dynamic')
like = db.relationship('Like', cascade="all, delete-orphan", backref="items", lazy='dynamic', )
num_views = db.Column(db.Integer, default=0)
def to_json_little(self):
return {
'post_id': self.post_id,
'title': self.title,
'date_post': self.date_post,
'num_comment': self.comments.count(),
'num_like': self.like.count(),
'num_views': self.num_views,
'tags': list(map(lambda d: {'tag_name': d.name, 'tag_id': d.tag_id}, self.tags.all()))
}
def to_json_full(self, author):
author['num_posts'] = Post.query.filter_by(author_id=author.get('user_id')).count()
ret = {
'post_id': self.post_id,
'title': self.title,
'body_html': self.body_html,
'date_post': self.date_post,
'num_comment': self.comments.count(),
'num_like': self.like.count(),
'author': author,
'num_views': self.num_views,
'tags': list(map(lambda d: {'tag_name': d.name, 'tag_id': d.tag_id}, self.tags.all()))
}
return ret
def to_json_summary(self, author):
ret = {
'post_id': self.post_id,
'title': self.title,
'date_post': self.date_post,
'num_comment': self.comments.count(),
'num_like': self.like.count(),
'author': author,
'num_views': self.num_views,
'tags': list(map(lambda d: {'tag_name': d.name, 'tag_id': d.tag_id}, self.tags.all()))
}
return ret
@staticmethod
def order_by_reputaiton():
return Post.num_views + Post.like.count() * 10
def index():
form = UploadForm()
submit_homework = getSubmitHomeWork()
form.course.choices = [(i, i) for i in submit_homework]
form.homeWork.choices = []
if bool(submit_homework):
form.homeWork.choices = [
(i, i) for i in submit_homework[list(submit_homework)[0]]
]
if form.validate_on_submit():
student_query = Student.query.filter_by(id=form.studentID.data).first()
if student_query is None:
flash('学号填写错误')
return render_template('index.html', form=form)
student_query = Student.query.filter_by(
id=form.studentID.data, real_name=form.name.data).first()
if student_query is None:
flash('学号与姓名不匹配')
return render_template('index.html', form=form)
basedir = current_app.config['BASE_DIR']
file_dir = os.path.join(basedir, "ZY", form.course.data,
student_query.course_names,
form.homeWork.data) # 拼接成合法文件夹地址
if not os.path.exists(file_dir):
os.makedirs(file_dir) # 文件夹不存在就创建
filename = form.file.data.filename
file = os.path.splitext(filename)
filename, file_type = file
new_filename = form.studentID.data + '_' + form.name.data + '_' + form.homeWork.data + file_type
files_query = FileRecord.query.filter_by(
student_id=student_query.id,
course_names=student_query.course_names,
home_work_id=int(form.homeWork.data[2:])).first()
if files_query is None:
form.file.data.save(os.path.join(file_dir, new_filename))
flash('作业上传成功')
fileRecord = FileRecord(student_id=student_query.id,
real_name=student_query.real_name,
home_work_id=int(form.homeWork.data[2:]),
course_names=student_query.course_names,
file_name=os.path.join(
file_dir, new_filename))
db.session.add(fileRecord)
else:
print(files_query.file_name)
os.remove(files_query.file_name)
files_query.file_name = os.path.join(file_dir, new_filename)
files_query.created_at = datetime.utcnow()
flash("您已成功覆盖上次提交")
form.file.data.save(os.path.join(file_dir, new_filename))
db.session.commit()
# if not os.path.exists(os.path.join(file_dir, new_filename)):
return render_template('index.html', form=form)
class Post(db.Model):
__tablename__ = 'posts'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(64))
body = db.Column(db.Text)
timestamp = db.Column(db.DateTime, index=True, default=datetime.utcnow())
body_html = db.Column(db.Text)
author_id = db.Column(db.Integer, db.ForeignKey('users.id'))
# 外码
comments = db.relationship('Comment', backref='article', lazy='dynamic')
labels = db.relationship('LabelArticle',
backref='article_label',
lazy='dynamic')
# 处理Markdown文档， 将文本渲染成html
@staticmethod
def on_changed_body(target, value, oldvlaue, initiator):
allowed_tags = [
'a', 'abbr', 'acronym', 'b', 'blockquote', 'code', 'em', 'i', 'li',
'ol', 'pre', 'strong', 'ul', 'h1', 'h2', 'h3', 'p'
]
# markdown():初步把Markdown文本转换为html
# bleach.clean():将不在白名单中标签清除
# bleach.linkify():将html中的<a>转换为链接
target.body_html = bleach.linkify(
bleach.clean(markdown(value, outout_format='html'),
tags=allowed_tags,
strip=True))
# 生成虚拟文章
@staticmethod
def generate_fake(count=100):
from random import seed, randint
import forgery_py
seed()
user_count = User.query.count()
for i in range(count):
u = User.query.offset(randint(0, 100)).first()
p = Post(title=forgery_py.internet.user_name(),
body=forgery_py.lorem_ipsum.sentences(randint(1, 3)),
timestamp=forgery_py.date.date(True),
author=u)
db.session.add(p)
db.session.commit()
class Post(db.Model):
__tablename__ = 'posts'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.Text)
body = db.Column(db.Text)
timestamp = db.Column(db.DateTime, index=True, default=datetime.utcnow())
author_id = db.Column(db.Integer, db.ForeignKey('users.id'))
comments = db.relationship('Comment', backref='post', lazy='dynamic')
@staticmethod
def on_changed_body(target, value, oldvalue, initiator):
allowed_tags = [
'a', 'abbr', 'acronym', 'b', 'blockquote', 'code', 'em', 'i', 'li',
'ol', 'pre', 'strong', 'ul', 'h1', 'h2', 'h3', 'p'
]
target.body_html = bleach.linkify(
bleach.clean(markdown(value, output_format='html'),
tags=allowed_tags,
strip=True))
def add_comment(user_id):
data = request.get_json()
body = data.get('body')
html = markdown(body)
list_text = BeautifulSoup(html, features='html.parser').find_all(text=True)
body_text = '.'.join(list_text)
comment = Comments(body=body_text,
body_html=body,
post_id=data.get('post_id'),
date_comment=datetime.utcnow(),
user_id=user_id)
with get_connection(post, name='profile') as conn:
resp = conn.get(ServiceURL.PROFILE_SERVICE +
'user_profile?profile_id=' + str(comment.user_id))
if resp.status_code != 200:
raise CustomException('Cannot found post', 404)
db.session.add(comment)
db.session.commit()
ret = comment.to_json(resp.json(), 0)
return jsonify(ret), 200
class Comment(db.Model):
__tablename__ = 'comments'
id = db.Column(db.Integer, primary_key=True)
post_id = db.Column(db.Integer, db.ForeignKey('posts.id'))
author_id = db.Column(
db.Integer, db.ForeignKey('users.id')) # 相当于在post里有一个.user可以直接拿到User
body = db.Column(db.Text)
timestamp = db.Column(db.DateTime, index=True, default=datetime.utcnow())
body_html = db.Column(db.Text)
@staticmethod
def on_change_body(target, value, oldvalue, initiator):
allowed_tags = [
'a', 'abbr', 'acronym', 'b', 'blockquote', 'code', 'em', 'i', 'li',
'ol', 'pre', 'strong', 'ul', 'h1', 'h2', 'h3', 'p', 'img'
]
target.body_html = bleach.linkify(
bleach.clean(markdown(value, output_format='html'),
tags=allowed_tags,
strip=True))
def ping(self):
# Refresh the time of last_seen
self.last_seen = datetime.utcnow()
db.session.add(self)
db.session.commit()
def ping(self):
self.last_seen = datetime.utcnow()
def ping(self):
self.last_seen = datetime.utcnow()
db.session.add(self)
class UserDetails(db.Model):
__tablename__ = 'user_details'
user_id = db.Column(db.Integer, primary_key=True, autoincrement=False)
name = db.Column(db.String(64))
email = db.Column(db.String(64), unique=True)
address = db.Column(db.String(128))
about_me = db.Column(db.Text())
member_since = db.Column(db.DateTime(), default=datetime.utcnow())
last_seen = db.Column(db.DateTime(), default=datetime.utcnow())
avatar_hash = db.Column(db.Text)
followed = db.relationship('Follow',
foreign_keys=[Follow.follower_id],
backref=db.backref('follower', lazy='joined'),
lazy='dynamic',
cascade='all, delete-orphan')
followers = db.relationship('Follow',
foreign_keys=[Follow.followed_id],
backref=db.backref('followed', lazy='joined'),
lazy='dynamic',
cascade='all, delete-orphan')
def __init__(self, **kwargs):
super(UserDetails, self).__init__(**kwargs)
def to_json(self):
json_user_details = {
'user_id': self.user_id,
'name': self.name,
'email': self.email,
'address': self.address,
'about_me': self.about_me,
'member_since': self.member_since,
'last_seen': self.last_seen,
'avatar_hash': self.avatar_hash,
'number_follower': self.followers.count(),
'number_followed': self.followed.count()
}
return json_user_details
def to_short_json(self):
short_json = {
'user_id': self.user_id,
'user_name': self.name,
'user_avatar': self.avatar_hash,
'number_follower': self.followers.count(),
'number_followed': self.followed.count()
}
return short_json
def ping(self):
self.last_seen = datetime.utcnow()
def is_following(self, user_id):
followed = self.followed.filter_by(followed_id=user_id).first()
if followed is not None:
return True
return False
def follow(self, user_id):
if not self.is_following(user_id):
f = Follow(follower_id=self.user_id,
followed_id=user_id,
date_follow=datetime.utcnow())
db.session.add(f)
def un_follow(self, user_id):
if self.is_following(user_id):
f = Follow.query.filter_by(followed_id=user_id).first()
if f is not None:
db.session.delete(f)
def gravatar(self, size=100, default='identicon', rating='g'):
url = 'https://secure.gravatar.com/avatar'
hash = hashlib.md5(self.email.lower().encode('utf-8')).hexdigest()
return '{url}/{hash}?s={size}&d={default}&r={rating}'.format(
url=url, hash=hash, size=size, default=default, rating=rating)
def ping(self):
'''载入最后一次访问的日期'''
self.last_seen = datetime.utcnow()
db.session.add(self)
def follow(self, user_id):
if not self.is_following(user_id):
f = Follow(follower_id=self.user_id,
followed_id=user_id,
date_follow=datetime.utcnow())
db.session.add(f)
def ping(self):
self.last_seen = datetime.utcnow()
db.session.add(self) #每次收到用户的请求时都要调用ping()方法。由于auth蓝本中的before_app_request处理程序会在每次请求前运行，所以能很轻松地实现这个需求。
