def delete_user(id):
"""修改单个用户"""
user = User.query.get_or_404(id)
if g.current_user != user and not g.current_user.can(Permission.ADMIN):
error_response(403)
db.session.delete(user)
db.session.commit()
return '', 204
def get_user_messages_recipients(id):
"""我给哪些用户发过私信，按用户分组，返回我给各用户最后一次发送的私信
即: 我给 (谁) 最后一次 发了 (什么私信)"""
user = User.query.get_or_404(id)
if g.current_user != user:
return error_response(403)
page = request.args.get('page', 1, type=1)
per_page = min(
request.args.get('per_page',
current_app.config['MESSAGES_PER_PAGE'],
type=int), 100)
data = Message.to_collection_dict(user.messages_sent.group_by(
Message.recipient_id).order_by(Message.timestamp.desc()),
page,
per_page,
'api.get_user_messages_recipients',
id=id)
for item in data['items']:
# 发给了谁
recipient = User.query.get_or_404(item['recipient']['id'])
# 发送给这个人的个数
item['total_count'] = user.messages_sent.filter_by(
recipient_id=item['recipient']['id']).count()
last_read_time = recipient.last_messages_read_time or datetime(
1900, 0, 0)
if item['timestamp'] > last_read_time:
item['is_new'] = True
# 继续获取发给这个用户的私信有几条是新的
item['new_count'] = user.messages_sent.filter_by(
recipient_id=item['recipient']['id']).filter(
Message.timestamp > last_read_time).count()
return jsonify(data)
def get_user_messages_senders(id):
'''哪些用户给我发过私信，按用户分组，返回各用户最后一次发送的私信
即: (谁) 最后一次 给我发了 (什么私信)'''
user = User.query.get_or_404(id)
if g.current_user != user:
return error_response(403)
page = request.args.get('page', 1, type=1)
per_page = min(
request.args.get('per_page',
current_app.config['MESSAGES_PER_PAGE'],
type=int), 100)
data = Message.to_collection_dict(user.messages_received.group_by(
Message.recipient_id).order_by(Message.timestamp.desc()),
page,
per_page,
'api.get_messages_senders',
id=id)
last_read_time = user.last_messages_read_time or datetime(1900, 0, 0)
new_items = []
not_new_items = []
for item in data['items']:
if item['timestamp'] > last_read_time:
item['is_new'] = True
# 新未读私信的总数
item['total_count'] = user.messages_received.filter_by(
sender_id=item['sender']['id']).filter(
Message.timestamp > last_read_time).count()
new_items.append(item)
else:
not_new_items.append(item)
# 对那些最后一条是新的按 timestamp 正序排序，不然用户更新 last_messages_read_time 会导致时间靠前的全部被标记已读
new_items = sorted(new_items, key=itemgetter('timestamp'))
data['items'] = new_items + not_new_items
return jsonify(data)
def get_user_notifications(id):
"""获取用户通知"""
user = User.query.get_or_404(id)
if g.current_user != user:
return error_response(403)
since = request.args.get('since', 0.0, type=float)
notifications = user.notifications.filter(
Notification.timestamp > since).order_by(Notification.timestamp.asc())
return jsonify([n.to_dict() for n in notifications])
def delete_message(id):
"""删除一条私信"""
message = Message.query.get_or_404(id)
if g.current_user != message.sender:
return error_response(403)
db.session.delete(message)
db.session.commit()
message.recipient.add_notification('unread_messages_count',message.recipient.new_recived_messages())
return '',204
def get_user_history_messages(id):
"""获取用户与某人的消息记录"""
user = User.query.get_or_404(id)
if g.current_user != user:
return error_response(403)
page = request.args.get('page', 1, type=int)
per_page = min(
request.args.get('per_page',
current_app.config['MESSAGES_PER_PAGE'],
type=int), 100)
from_id = request.args.get('from', type=int)
if not from_id:
return bad_request("You must provide the user id of opposite site")
# 对方发给我的message
q1 = Message.query.filter(Message.sender_id == from_id,
Message.recipient_id == user.id)
# 我给对方发送的message
q2 = Message.query.filter(Message.sender_id == user.id,
Message.recipient_id == from_id)
# 按时间正序排序
history_messages = q1.union(q2).order_by(Message.timestamp)
data = Message.to_collection_dict(history_messages,
page,
per_page,
'api.get_user_history_messages',
id=id)
recived_message = [
item for item in data['items'] if item['sender']['id'] != id
]
sent_message = [
item for item in data['items'] if item['sender']['id'] == id
]
last_read_time = user.last_messages_read_time or datetime(1900, 0, 0)
new_count = 0
for item in recived_message:
if item['timestamp'] > last_read_time:
item['is_new'] = True
new_count += 1
# 未读的私信个数
if new_count > 0:
user.last_messages_read_time = recived_message[-1]['timestamp']
db.session.commit()
user.add_notification('unread_message_count',
user.new_recived_messages())
db.session.commit()
messages = recived_message + sent_message
messages.sort(key=data['items'].index)
data['items'] = messages
return jsonify(data)
def update_comment(id):
"""修改单个评论"""
comment = Comment.query.get_or_404(id)
if g.current_user != comment.author and g.current_user != comment.post.author:
return error_response(403)
json_data = request.json
if not json_data:
return bad_request('You must post JSON data.')
comment.from_dict(json_data)
db.session.commit()
return jsonify(comment.to_dict())
def delete_post(id):
"""删除一篇文章"""
post = Post.query.get_or_404(id)
if post.id != g.current_user.id and not g.current_user.can(
Permission.ADMIN): # 管理员也可以删除文章
return error_response(403)
db.session.delete(post)
for user in post.author.followers:
user.add_notification('unread_followeds_posts_count',
user.new_followeds_posts())
db.session.commit()
return "", 204
def get_user_tasks_in_progress(id):
user = User.query.get_or_404(id)
if g.current_user != user:
return error_response(403)
page = request.args.get('page', 1, type=int)
per_page = min(
request.args.get('per_page',
current_app.config['TASKS_PER_PAGE'],
type=int), 100)
data = Task.to_collection_dict(
Task.query.filter_by(user_id=user.id, complate=False).all(),
page,
per_page,
endpoint=url_for('api.get_user_tasks_in_progress', id=id))
return jsonify(data)
def update_message(id):
"""修改一条私信"""
message = Message.query.get_or_404(id)
if g.current_user != message.sender:
return error_response(403)
json_data = request.json
if not json_data:
return bad_request('You must post JSON data.')
if 'body' not in json_data or not json_data.get('body'):
return bad_request('Body is required.')
message.from_dict(json_data)
db.session.commit()
return jsonify(message.to_dict())
def get_user_liked_posts(id):
"""返回用户收藏的文章"""
user = User.query.get_or_404(id)
if user != g.current_user:
return error_response(403)
page = request.args.get('page', 1, type=int)
per_page = min(
request.args.get('per_page',
current_app.config['POSTS_PER_PAGE'],
type=int), 100)
data = Post.to_collection_dict(user.liked_posts.order_by(
Post.timestamp.desc()),
page,
per_page,
'api.get_user_liked_posts',
id=id)
return jsonify(data)
def update_post(id):
"""更新一篇文章"""
post = Post.query.get_or_404(id)
if g.current_user.id != post.author_id:
return error_response(403)
json_data = request.json
if not json_data:
return bad_request("you must post Json data")
message = {}
if 'title' not in json_data and not json_data.get("title"):
message["title"] = "title is required"
elif len(json_data["title"]) > 255:
message["title"] = "title must less than 255"
if "body" not in json_data and not json_data.get("body"):
message["body"] = "body is required"
if message:
return bad_request(message)
post.from_dict(json_data)
db.session.add(post)
db.session.commit()
return jsonify(post.to_dict())
def delete_comment(id):
"""删除单个评论"""
comment = Comment.query.get_or_404(id)
if g.current_user != comment.author and g.current_user != comment.post.author and not g.current_user.can(
Permission.ADMIN):
return error_response(403)
# 获取当前评论所有的祖先评论的作者
users = set()
users.add(comment.post.author)
if comment.parent:
ancestors_authors = {c.author for c in comment.get_ancestors()}
users = users | ancestors_authors
db.session.delete(comment)
db.session.commit()
# 给所有的祖先评论作者发送通知
for u in users:
u.add_notification('unread_recived_comments_count',
u.new_recived_comments())
return '', 204
def get_user_recived_comments(id):
"""获取用户收到的所有评论"""
user = User.query.get_or_404(id)
if g.current_user != user:
return error_response(403)
page = request.args.get('page', 1, type=int)
per_page = min(
request.args.get('per_page',
current_app.config['COMMENTS_PER_PAGE'],
type=int), 100)
# 用户发布的所有文章ID集合
user_post_ids = [post.id for post in g.current_user.posts.all()]
# 评论的posts.id在user_post_ids中,且评论的用户不是当前用户.
data = Comment.to_collection_dict(
Comment.query.filter(Comment.post_id in user_post_ids,
Comment.author != g.current_user).order_by(
Comment.mark_read, Comment.timestamp.desc()))
# 标记哪些评论是最新的
last_read_time = user.last_recived_comments_read_time or datetime(
1900, 1, 1)
for item in data['items']:
if item['timestamp'] > last_read_time:
item['is_new'] == True
if data['_meta']["page"] * data['_meta'][
"perpage"] >= user.new_recived_comments():
user.last_recived_comments_read_time = datetime.utcnow()
user.add_notification('unread_recived_comments_count', 0)
else:
n = user.new_recived_comments(
) - data['_meta']["page"] * data['_meta']["perpage"]
user.add_notification('unread_recived_comments_count', n)
db.session.commit()
return jsonify(data)
def token_auth_error():
"""token认证失败"""
return error_response(401)
def basic_auth_error():
"""认证失败,并返回401信息"""
return error_response(401)
def get_user_recived_posts_likes(id):
"""返回用户收到的文章喜欢"""
user = User.query.get_or_404(id)
if user != g.current_user:
return error_response(403)
page = request.args.get('page', 1, type=int)
per_page = min(
request.args.get('per_page',
current_app.config['POSTS_PER_PAGE'],
type=int), 100)
posts = user.posts.join(posts_likes).paginate(page, per_page)
# 喜欢的记录
# items :[data1,date2,date3]
# data1:{post:{},user:{},timestamp:1989,is_new=True}
records = {
'items': [],
'_meta': {
'page': page,
'per_page': per_page,
'total_page': posts.pages,
'total_items': posts.total
},
'_links': {
'self':
url_for('api.get_user_recived_posts_likes',
page=page,
per_page=per_page,
id=id),
'next':
url_for('api.get_user_recived_posts_likes',
page=page + 1,
per_page=per_page,
id=id) if posts.has_next else None,
'prev':
url_for('api.get_user_recived_posts_likes',
page=page - 1,
per_page=per_page,
id=id) if posts.has_prev else None,
}
}
for p in posts.items:
for u in p.likes:
if u != user:
data = dict()
data["user"] = u.to_dict()
data['post'] = p.to_dict()
res = db.engine.execute(
"select * from posts_likes where user_id={} and post_id={}"
.format(u.id, p.id))
data["timestamp"] = datetime.strptime(
list(res)[0][2], "%Y-%m-%d %H:%M:%S.%f")
last_read_time = user.last_posts_likes_read_time or datetime(
1900, 0, 0)
if data["timestamp"] > last_read_time:
data["is_new"] = True
records['items'].append(data)
records['items'] = sorted(records['items'],
key=itemgetter('timestamp'),
reverse=True)
user.last_posts_likes_read_time = datetime.utcnow()
user.add_notification('unread_posts_likes_count', 0)
db.session.commit()
return jsonify(records)
def basic_auth_error(status):
return error_response(status)
def token_auth_error():
return error_response(401)
def basic_auth_error():
'''Return error response when fail to authorize'''
return error_response(401)
def get_notification(id):
notification = Notification.query.get_or_404(id)
if g.current_user != notification.user:
return error_response(403)
data = notification.to_dict()
return jsonify(data)
def token_auth_error(status):
return error_response(status)