def cached_replied_topics(user_id):
"""
根据user id 返回该用户回复的Topic对象。
如果缓存命中，从缓存中拉取包含多个Topic id的列表，根据每个Topic id调用cached_topic_id2topic得到Topic model。
如果缓存穿透，则从数据库查询，拿到多个Topic对象，将所有Topic id 序列化后存储到redis，返回多个Topic对象。
"""
key = 'user_id_{}.replied_topics'.format(user_id)
try:
# 缓存命中
topics_ids_json = data_cache[key]
except KeyError:
# 缓存未命中，数据库中拉取数据
# ORM 的n+1老问题。。。
replies = list(Reply.all(user_id=user_id))
topics_ids = [reply.topic_id for reply in replies]
# 加到redis缓存中的是topic id
data_cache.set(key, json.dumps(topics_ids), 1800)
topics_models = [
cached_topic_id2topic(topic_id) for topic_id in topics_ids
]
topics_models.sort(key=lambda x: x.last_active_time, reverse=True)
log('缓存丢失，向数据库拉取数据，重建缓存')
return topics_models
else:
# 缓存命中则根据缓存中的多个Topic id，再调用 cached_topic_id2topic 获得多个Topic对象，排序后返回。
topics_models = [
cached_topic_id2topic(topic_id)
for topic_id in json.loads(topics_ids_json)
]
topics_models.sort(key=lambda x: x.last_active_time, reverse=True)
log('缓存命中，直接使用')
return topics_models
def cached_replies_by_topic_id(topic_id):
"""
根据Topic id ,返回属于该Topic的所有Reply对象。
如果缓存命中，从缓存中拿到包含了多个字典的列表，每个字典都生成一个对应的Reply对象。
如果缓存穿透，从数据库中查询，拿到多个Reply对象，将每个Reply经json序列化后建立缓存。
"""
key = 'topic_id_{}.replies'.format(topic_id)
try:
# 缓存命中
replies_json = data_cache[key]
except KeyError:
# 缓存未命中，数据库中拉取数据
replies = list(Reply.all(topic_id=topic_id))
replies.sort(key=lambda x: x.created_time)
# 数据库中拿到的数据json序列化后建立缓存，一个Reply对应一个字典
data_cache.set(key, json.dumps([r.json() for r in replies]), 900)
log('缓存丢失，向数据库拉取数据，重建缓存')
return replies
else:
# 反序列化后得到字典，使用字典生成Reply对象
replies = [Reply.get_model(r) for r in json.loads(replies_json)]
replies.sort(key=lambda x: x.created_time)
log('缓存命中，直接使用')
return replies
def replied_topic(user_id):
# O(k)+O(m*n)
# rs = Reply.all(user_id=user_id)
# ts = []
# for r in rs:
# t = Topic.one(id=r.topic_id)
# ts.append(t)
# return ts
#
# sql = """
# select * from topic
# join reply on reply.topic_id=topic.id
# where reply.user_id=1
# """
k = 'replied_topic_{}'.format(user_id)
if cache.exists(k):
v = cache.get(k)
ts = json.loads(v)
return ts
else:
rs = Reply.all(user_id=user_id)
ts = []
for r in rs:
t = Topic.one(id=r.topic_id)
ts.append(t)
v = json.dumps([t.json() for t in ts])
cache.set(k, v)
return ts
def replied_topic(user_id):
# O(k)+O(m*n)
# rs = Reply.all(user_id=user_id)
# ts = []
# for r in rs:
# t = Topic.one(id=r.topic_id)
# ts.append(t)
# return ts
#
k = 'replied_topic_{}'.format(user_id)
if cache.exists(k):
v = cache.get(k)
ts = json.loads(v)
log('replied', 'key', k, ts, 'ts type<{}>'.format(type(ts)))
return ts
else:
rs = Reply.all(user_id=user_id)
ts = []
for r in rs:
t = Topic.one(id=r.topic_id)
ts.append(t)
serialized_ts = []
for i, t in enumerate(ts):
ts.pop(i)
log('replied t type', type(t), t)
if t is not None:
serialized_ts.append(t.json())
v = json.dumps(serialized_ts)
log('replied ts', ts)
cache.set(k, v)
return ts
def user_detail(id):
u = User.one(id=id)
if u is None:
abort(404)
else:
k = 'topics_{}'.format(id)
if cache.exists(k):
v = cache.get(k)
topics = json.loads(v)
print("正在使用缓存")
else:
topics: list = Topic.all(user_id=u.id)
topics.sort(key=lambda i: i.created_time, reverse=True)
replys: list = Reply.all(user_id=u.id)
print('<user_detail replys {}'.format(replys))
re_topics = []
for reply in replys:
topic = Topic.one(id=reply.topic_id)
if topic not in re_topics:
re_topics.append(topic)
print('<user_detail re_topics {}'.format(re_topics))
v = json.dumps([t.json() for t in topics])
cache.set(k, v)
return render_template('user/profile.html',
user=u,
topics=topics,
re_topics=[])
def profile(username=None):
if username:
u = User.one(username=username)
if u is None:
return abort(404)
else:
u = current_user()
if u is None:
return redirect(url_for('.login'))
create_topic = Topic.all(user_id=u.id)
create_topic = sorted(create_topic,
key=lambda k: k.created_time,
reverse=True)
reply = Reply.all(user_id=u.id)
reply_topic = []
for r in reply[::-1]:
topic = Topic.one(id=r.topic_id)
reply_topic.append(topic)
return render_template(
'profile.html',
user=u,
created=create_topic,
replied=reply_topic,
)
def last_reply(self):
ms = Reply.all(topic_id=self.id)
ms = sorted(ms, key=lambda m: m.created_time, reverse=True)
if len(ms) > 0:
return ms[0]
else:
return None
def data_form_user(u):
ms = Topic.all(user_id=u.id)
rs = Reply.all(user_id=u.id)
ms = reverse(ms)
ts = reply_filter(rs)
ts = reverse(ts)
return ms, ts
def replied_topic(user_id):
# O(m*n)
# rs = Reply.all(user_id=user_id)
# ts = []
# for r in rs:
# t = Topic.one(id=r.topic_id)
# ts.append(t)
# return ts
k = 'replied_topic_{}'.format(user_id)
if cache.exists(k):
v = cache.get(k)
ts = json.loads(v)
return ts
else:
rs = Reply.all(user_id=user_id)
ts = []
for r in rs:
t = Topic.one(id=r.topic_id)
ts.append(t)
v = json.dumps([t.json() for t in ts])
cache.set(k, v)
return ts
def topics_for_index(board_id, page_num=1, page_limit=10):
limit = page_limit
offset = (page_num - 1) * page_limit
if board_id == -1:
ms = Topic.all_by_offset(offset, limit)
else:
ms = Topic.all_by_offset(offset, limit, board_id=board_id)
topics = []
for m in ms:
t = m.json()
t['user'] = User.one(id=t['user_id']).json()
replies = Reply.all(topic_id=t['id'])
replies.sort(key=lambda r: r.created_time)
if len(replies) > 0:
last_reply = replies[0].json()
last_reply['user'] = User.one(id=last_reply['user_id']).json()
else:
last_reply = None
t['lastReply'] = last_reply
t['replies'] = len(replies)
topics.append(t)
log('topics', topics)
topics.sort(key=lambda t: t['created_time'], reverse=True)
return topics
def replied_topic(user_id):
rs = Reply.all(user_id=user_id)
ts = []
for r in rs:
t = Topic.one(id=r.topic_id)
ts.append(t)
return ts
def involved_ts_count(self):
rs = Reply.all(user_id=self.id)
ts = {}
for r in rs:
tid = r.topic_id
ts[tid] = tid
return len(ts.keys())
def profile():
u = current_user()
ms = Topic.all()
ms_d = {}
for c in ms:
ms_d[str(c.id)] = c.created_time
ms_d = sorted(ms_d.items(), key=itemgetter(1), reverse=True)
ms_created = []
for c in ms_d:
t = Topic.one(id=int(c[0]), user_id=u.id)
if t is None:
continue
else:
ms_created.append(t)
replies = Reply.all(user_id=u.id)
rs_d = {}
for r in replies:
rs_d[str(r.topic_id)] = r.created_time
rs_d = sorted(rs_d.items(), key=itemgetter(1), reverse=True)
ms_recented = []
for r in rs_d:
print('types', type(r))
ms_recented.append(Topic.one(id=int(r[0])))
return render_template(
"profile.html",
ms_created=ms_created,
ms_recented=ms_recented,
user=u,
)
def delete(cls, id):
# 删除帖子下所有评论
rs = Reply.all(topic_id=id)
for r in rs:
Reply.delete(r.id)
# 删除帖子
super().delete(id)
return '成功删除'
def delete():
id = int(request.args.get('id'))
u = current_user()
print('删除 topic 用户是', u, id)
Topic.delete(id)
m = Reply.all(topic_id=id)
for i in m:
Reply.delete(i.id)
return redirect(url_for('.index'))
def replied_topic(user_id):
# O(k)+O(m*n)
rs = Reply.all(user_id=user_id)
ts = []
for r in rs:
t = Topic.one(id=r.topic_id)
ts.append(t)
ts = sorted(ts, key=lambda m: m.created_time, reverse=True)
return ts
def get_reply_topics(uid):
reply_topics = []
tids = []
replies = order(Reply.all(user_id=uid))
for r in replies:
if r.topic_id not in tids:
reply_topics.append(Topic.one(id=r.topic_id))
tids.append(r.topic_id)
return reply_topics
def user_detail(id):
u = User.one(id=id)
if u is None:
return redirect(url_for('.index'))
else:
ms_recent = Topic.all(user_id=u.id)
ms_sort = sorted(ms_recent, key=lambda Topic: Topic.updated_time, reverse=True)
replies = Reply.all(user_id=u.id)
replies_sort = sorted(replies, key=lambda Reply: Reply.updated_time, reverse=True)
return render_template('topic/person_file.html', user=u, ms=ms_sort, ts=replies_sort)
def user_detail(id):
u = User.find(id)
if u is None:
abort(404)
else:
topic = Topic.all()
reply = Reply.all()
t = sorted(topic, key=lambda l: l.updated_time, reverse=True)
r = sorted(reply, key=lambda s: s.updated_time, reverse=True)
return render_template('profile.html', user=u, topic=t, reply=r)
def profile():
u = current_user()
if u is None:
return redirect(url_for('.index'))
else:
topic = Topic.all()
reply = Reply.all()
t = sorted(topic, key=lambda l: l.updated_time, reverse=True)
r = sorted(reply, key=lambda s: s.updated_time, reverse=True)
return render_template('profile.html', user=u, topic=t, reply=r)
def profile_index(username):
can_edit = True
user = User.one(username=username)
log(f'USER<{username}>:{user}')
user_id = user.id
replys = Reply.all(writer_id=user_id)
replys.reverse()
topics = Topic.all_order(writer_id=user_id)
return render_template('profile.html', user=user, replys=replys, topics=topics, can_edit=can_edit)
def delete(cls, t):
replies = Reply.all(topic_id=t.id)
deleted_rep_id_list = []
for r in replies:
r_id = r.id
db.session.delete(r)
deleted_rep_id_list.append(r_id)
db.session.delete(t)
db.session.commit()
return deleted_rep_id_list
def profile():
u = current_user()
topics = Topic.all(user_id=u.id)
replys = Reply.all(user_id=u.id)
if u is None:
return redirect(url_for('.index'))
else:
return render_template('profile.html',
user=u,
topics=topics,
replys=replys)
def user_detail(id):
u = User.one(id=id)
topics = Topic.all(user_id=u.id)
replys = Reply.all(user_id=u.id)
if u is None:
os.abort(404)
else:
return render_template('profile.html',
user=u,
topics=topics,
replys=replys)
def topic_returned(m):
t = m.json()
t['user'] = User.one(id=t['user_id']).json()
t['board'] = Board.one(id=t['board_id']).title
replies = Reply.all(topic_id=t['id'])
replies.sort(key=lambda r: r.created_time)
# last_reply = replies[0].json()
# last_reply['user'] = User.one(id=last_reply['user_id']).json()
t['replies'] = replies_returned(replies)
# t['replies'] = len(replies)
return t
def index(id):
u = User.one(id=id)
t1 = Topic.all(user_id=id)
t = list(reversed(t1))
r1 = Reply.all(user_id=id)
r = list(reversed(r1))
topic = []
for each in r:
one = Topic.one(id=each.topic_id)
topic.append(one)
return render_template("homepage.html", user=u, topic=t, topic2=topic)
def detail():
result = request.args.get('result', ' ')
topic_id = request.args['id']
m = Topic.get(topic_id)
rs = Reply.all(topic_id=topic_id)
token = new_csrf_token()
return render_template("topic/detail.html",
topic=m,
replies=rs,
token=token,
result=result)
def recently_replied_topic(cls, u):
# 先拿到创建的所有回复，再根据回复拿到对应的topic，user->reply->topic
rs = Reply.all(user_id=u.id)
sorted_rs = sorted(rs, key=lambda r: r.created_time, reverse=True)
ts = [cls.one(id=r.topic_id) for r in sorted_rs]
print('ts')
[print(t.id) for t in ts]
sorted_ts = cls.no_repeat(ts)
print('after')
[print(t.id) for t in sorted_ts]
return sorted_ts
def userinfo(name):
u = User.one(username=name)
#找到自己创建的topic
ts = Topic.all(user_id=u.id)
#参与过的
rs = Reply.all(user_id=u.id)
tes = []
for r in rs:
tes.append(Topic.one(id=r.topic_id))
return render_template('userinfo.html', ts=ts, tes=tes, user=u)
def profile():
u = current_user()
t = Topic.all(user_id=u.id)
t.reverse()
r = Reply.all(user_id=u.id)
r.reverse()
print('t是什么：', t)
print('r是什么:', r)
if u is None:
return redirect(url_for('.index'))
else:
return render_template('profile.html', user=u, topic=t, reply=r)