def cancel_favor(request):
data = request.data
if not data.get("comment_id"):
return Response({"status": 400, "msg": "参数错误"})
workspace = WorkspaceUtil.get_workspace(request)
passport_id = workspace.passport_id
# 判断该用户点赞
kwargs = {}
kwargs["passport_id"] = passport_id
kwargs["comment_id"] = data["comment_id"]
comment_favour = commentFavourRepository.load(**kwargs)
if not comment_favour:
where = {}
where["comment_id"] = data["comment_id"]
count = commentFavourRepository.count(**where)
return Response({"status": 200, "msg": "取消点赞成功", "data": count})
# 点赞减1
CommentFavour(passport_id=passport_id,
comment_id=data["comment_id"]).delete()
# 返回此评论赞
where = {}
where["comment_id"] = data["comment_id"]
count = commentFavourRepository.count(**where)
return Response({"status": 200, "msg": "取消点赞成功", "data": count})
def detail(request):
data = request.GET
if not data.get("id"):
return Response({"status": 400, "msg": "参数错误"})
kwargs = {}
kwargs["id"] = data["id"]
article = articleRepository.load(**kwargs)
if not article:
return Response({"status": 404, "msg": "文章不存在"})
# 获取 passport
kwargs = {}
kwargs["id"] = article.passport_id
passport = passportRepository.load(**kwargs)
article = ArticleSerializers(article).data
if (passport):
article["passport_name"] = passport.name
article["avert"] = passport.avert
workspace = WorkspaceUtil.get_workspace(request)
article["is_collect"] = False
if workspace:
passport_id = workspace.passport_id
kwargs = {"passport_id": passport_id, "article_id": data["id"]}
collect = collectRepository.load(**kwargs)
if collect:
article["is_collect"] = True
return Response({"status": 200, "data": article})
def create(request):
data = request.data
workspace = WorkspaceUtil.get_workspace(request)
if not workspace:
return Response({"status": 401, "msg": "token过期"})
if not data.get("catalog_id"):
return Response({"status": 400, "msg": "参数错误"})
kwargs = {}
kwargs["id"] = data["catalog_id"]
catalog = catalogRepository.load(**kwargs)
if not catalog:
return Response({"status": 404, "msg": "类目不存在"})
article = Article()
article.passport_id = workspace.passport_id
article.passport_name = workspace.name
article.catalog_id = data.get("catalog_id")
article.catalog_name = catalog.name
article.title = data.get("title")
article.content = data.get("content")
article.created = TimeUtil.get_utc_time()
article.pv = 0
article.version = 1
article.save()
return Response({"status": 200, "msg": "新增成功"})
def unread(request):
workspace = WorkspaceUtil.get_workspace(request)
if not workspace:
return Response({"status": 401, "msg": "token过期"})
passport_id = workspace.passport_id
kwargs = {"passport_id": passport_id, "status": 0}
count = messageRepository.count(**kwargs)
return Response({"status": 200, "data": count})
def follow(request):
data = request.data
workspace = WorkspaceUtil.get_workspace(request)
if not workspace:
return Response({"status": 401, "msg": "token过期"})
passport_id = workspace.passport_id
follow_id = data["follow_id"]
follow = Follow()
follow.passport_id = passport_id
follow.follow_id = follow_id
follow.save()
return Response({"status": 200, "msg": "关注成功"})
def collect_list(request):
data = request.GET
page = user_settings.page
page_size = user_settings.pageSize
if data.get("page"):
page = data["page"]
if data.get("page_size"):
page_size = data["page_size"]
workspace = WorkspaceUtil.get_workspace(request)
if not workspace:
return Response({"status": 401, "msg": "token过期"})
passport_id = workspace.passport_id
kwargs = {"passport_id": passport_id}
collect_list = collectRepository.search(page_size, page, **kwargs)
article_ids = []
for item in collect_list:
article_ids.append(item.article_id)
# 获取文章列表
article_list = []
if len(article_ids) > 0:
# 获取文章评论量
comment_dict = {}
if article_ids:
where = {}
where["article_id__in"] = article_ids
comment_list = commentRepository.group(**where)
for item in comment_list:
comment_dict[item["article_id"]] = item["count"]
kwargs = {"ids": article_ids}
article_list = articleRepository.search(**kwargs)
article_list = ArticleSerializers(article_list, many=True).data
for item in article_list:
item["reply"] = comment_dict.get(item["id"], 0)
count = collectRepository.count(**kwargs)
return Response({
"status": 200,
"msg": "",
"data": {
"count": count,
"data": article_list
}
})
def improve_user_information(request):
data = request.data
workspace = WorkspaceUtil.get_workspace(request)
passport_id = workspace.passport_id
data["id"] = passport_id
# 判断用户名是否存在
if data.get("name"):
kwargs = {}
kwargs["name"] = data["name"]
passport = passportRepository.load(**kwargs)
if passport and passport.id != passport_id:
return Response({"status": 400, "msg": "昵称已存在"})
passportRepository.modify(**data)
return Response({"status": 200, "msg": "修改成功"})
def be_followed_list(request):
workspace = WorkspaceUtil.get_workspace(request)
if not workspace:
return Response({"status": 401, "msg": "token过期"})
passport_id = workspace.passport_id
kwargs = {}
kwargs["follow_id"] = passport_id
follow_list = passportRepository.follow(**kwargs)
passport_ids = []
for item in follow_list:
passport_ids.append(item.passport_id)
kwargs = {}
kwargs["id__in"] = passport_ids
passport_list = passportRepository.search(1, 1000, **kwargs)
passport_list = RegisterSerializers(passport_list).data
return Response({"status": 200, "data": passport_list, "msg": "获取被关注者列表成功"})
def cancel_collect(request):
data = request.data
if not data.get("article_id"):
return Response({"status": 400, "msg": "参数错误"})
workspace = WorkspaceUtil.get_workspace(request)
if not workspace:
return Response({"status": 401, "msg": "token过期"})
article_id = data["article_id"]
passport_id = workspace.passport_id
kwargs = {"article_id": article_id, "passport_id": passport_id}
collect = collectRepository.load(**kwargs)
if not collect:
return Response({"status": 400, "msg": "取消收藏文章成功"})
collectRepository.delete(**kwargs)
return Response({"status": 200, "msg": "取消收藏文章成功"})
def list(request):
workspace = WorkspaceUtil.get_workspace(request)
if not workspace:
return Response({"status": 401, "msg": "token过期"})
passport_id = workspace.passport_id
kwargs = {"passport_id": passport_id}
data = request.data
if data.get("status"):
kwargs["status"] = data["status"]
page = user_settings.page
page_size = user_settings.pageSize
if data.get("page"):
page = data["page"]
if data.get("page_size"):
page_size = data["page_size"]
count = messageRepository.count(**kwargs)
messages = messageRepository.search(page_size, page, **kwargs)
# 获取文章信息
article_ids = []
for item in messages:
if item.article_id not in article_ids:
article_ids.append(item.article_id)
article_dict = {}
if len(article_ids) > 0:
kwargs = {"ids": article_ids}
articles = articleRepository.search(**kwargs)
for item in articles:
article_dict[item.id] = item
messages = MessageSerializers(messages, many=True).data
for item in messages:
article = article_dict[item["article_id"]]
item["catalog_id"] = article.catalog_id
item["article_title"] = article.title
ret_data = {"data": messages, "count": count}
return Response({"status": 200, "data": ret_data})
def detail(request):
data = request.GET
id = ""
if data.get("id"):
id = data["id"]
else:
workspace = WorkspaceUtil.get_workspace(request)
if not workspace:
return Response({"status": 401, "msg": "登录超时,请重新登录"})
id = workspace.passport_id
kwargs = {"id": id}
passport = passportRepository.load(**kwargs)
if not passport:
return Response({"status": 404, "msg": "用户不存在"})
passport = RegisterSerializers(passport).data
del passport["password"]
del passport["mobile"]
del passport["email"]
return Response({"status": 200, "msg": "", "data": passport})
def collect(request):
data = request.data
if not data.get("article_id"):
return Response({"status": 400, "msg": "参数错误"})
workspace = WorkspaceUtil.get_workspace(request)
if not workspace:
return Response({"status": 401, "msg": "token过期"})
article_id = data["article_id"]
passport_id = workspace.passport_id
kwargs = {"article_id": article_id, "passport_id": passport_id}
collect = collectRepository.load(**kwargs)
if collect:
return Response({"status": 400, "msg": "已收藏"})
utc_time = TimeUtil.get_utc_time()
collect = Collect(article_id=article_id,
passport_id=passport_id,
created=utc_time)
collect.save()
return Response({"status": 200, "msg": "收藏文章成功"})
def favor(request):
data = request.data
if not data.get("comment_id"):
return Response({"status": 400, "msg": "参数错误"})
workspace = WorkspaceUtil.get_workspace(request)
passport_id = workspace.passport_id
kwargs = {"id": data["comment_id"]}
comment = commentRepository.load(**kwargs)
if not comment:
return Response({"status": 400, "msg": "该评论不存在"})
if comment.passport_id == passport_id:
return Response({"status": 400, "msg": "不能给自己点赞"})
# 判断该用户点赞
kwargs = {}
kwargs["passport_id"] = passport_id
kwargs["comment_id"] = data["comment_id"]
comment_favour = commentFavourRepository.load(**kwargs)
if comment_favour:
where = {}
where["comment_id"] = data["comment_id"]
count = commentFavourRepository.count(**where)
return Response({"status": 200, "msg": "点赞成功", "data": count})
# 点赞+1
comment_favour = CommentFavour(passport_id=passport_id,
comment_id=data["comment_id"])
comment_favour.save()
# 返回此评论赞
where = {}
where["comment_id"] = data["comment_id"]
count = commentFavourRepository.count(**where)
return Response({"status": 200, "msg": "点赞成功", "data": count})
def list(request):
data = request.GET
kwargs = {}
if data.get("catalog_id"):
kwargs["catalog_id"] = data["catalog_id"]
if data.get("order_by"):
kwargs["order_by"] = data["order_by"]
# 获取自己文章列表
if data.get("owner"):
workspace = WorkspaceUtil.get_workspace(request)
if not workspace:
return Response({"status": 401, "msg": "token过期"})
passport_id = workspace.passport_id
kwargs["passport_id"] = passport_id
if data.get("passport_id"):
kwargs["passport_id"] = data["passport_id"]
page = user_settings.page
page_size = user_settings.pageSize
if data.get("page"):
page = data["page"]
if data.get("page_size"):
page_size = data["page_size"]
passport_ids = []
article_list = articleRepository.search(page_size, page, **kwargs)
article_ids = []
for item in article_list:
article_ids.append(item.id)
passport_ids.append(item.passport_id)
# 获取一次用户对象
where = {}
where["id__in"] = passport_ids
passport_list = passportRepository.search(page_size, 1, **where)
passport_dict = {}
for item in passport_list:
if item.id not in passport_dict:
passport_dict[item.id] = item
# 获取文章评论量
comment_dict = {}
if article_ids:
where = {}
where["article_id__in"] = article_ids
comment_list = commentRepository.group(**where)
for item in comment_list:
comment_dict[item["article_id"]] = item["count"]
count = articleRepository.count(**kwargs)
article_list = ArticleSerializers(article_list, many=True).data
for item in article_list:
passport = passport_dict.get(item["passport_id"])
item["reply"] = comment_dict.get(item["id"], 0)
if passport:
item["passport_name"] = passport.name
item["avert"] = passport.avert
else:
item["passport_name"] = ""
item["avert"] = ""
del item["content"]
response_data = {"data": article_list, "count": count}
return Response({"status": 200, "data": response_data})
def list(request):
data = request.GET
page = user_settings.page
page_size = user_settings.pageSize
if data.get("page"):
page = data["page"]
if data.get("page_size"):
page_size = data["page_size"]
if not data.get("article_id"):
return Response({"status": 400, "msg": "参数错误"})
kwargs = {}
kwargs["article_id"] = data["article_id"]
comment_list = commentRepository.search(page_size, page, **kwargs)
# 获取评论人头像, 名字信息, 评论字典
passport_ids = []
comment_ids = []
comment_parents = []
comment_parents_dict = {}
for item in comment_list:
passport_ids.append(item.passport_id)
comment_ids.append(item.id)
if item.layer > 1:
comment_parents.append(item.parent_id)
# 获取@人信息
if len(comment_parents) > 0:
where = {}
where["comment_id__in"] = comment_parents
comments = commentRepository.search(page_size, page, **kwargs)
for item in comments:
passport_ids.append(item.passport_id)
comment_parents_dict[item.id] = item.passport_id
where = {}
where["id__in"] = passport_ids
passport_list = passportRepository.search(int(page_size) * 2, 1, **kwargs)
passport_dict = {}
for item in passport_list:
passport_dict[item.id] = item
# 获取评论量点赞总量
where = {}
where["comment_id__in"] = comment_ids
favor_count = {}
comment_favour_list = commentFavourRepository.group(**where)
for item in comment_favour_list:
favor_count[item["comment_id"]] = item["dcount"]
# 已点赞id
favor_ids = []
# 获取当前用户已点赞评论
workspace = WorkspaceUtil.get_workspace(request)
if workspace:
passport_id = workspace.passport_id
where["passport_id"] = passport_id
where["comment_id__in"] = comment_ids
favour_list = commentFavourRepository.search(page_size, 1, **where)
for item in favour_list:
favor_ids.append(item.comment_id)
comment_list = CommentSerializers(comment_list, many=True).data
for item in comment_list:
passport = passport_dict[item["passport_id"]]
item["favor_count"] = favor_count.get(item["id"], 0)
item["is_favor"] = False
if item["id"] in favor_ids:
item["is_favor"] = True
if passport:
item["avert"] = passport.avert
item["passport_name"] = passport.name
else:
item["avert"] = passport.avert
item["passport_name"] = passport.name
if item["layer"] > 1:
reply_passport = passport_dict[comment_parents_dict[
item["parent_id"]]]
item["reply_id"] = reply_passport.id
item["reply_name"] = reply_passport.name
count = commentRepository.count(**kwargs)
response_data = {"count": count, "data": comment_list}
return Response({"status": 200, "data": response_data})
def add_comment(request):
data = request.data
parent_id = data.get('parent_id', 0)
content = data.get("content")
article_id = data.get("article_id")
if not (content and article_id):
return Response({"status": 400, "msg": "参数错误"})
kwargs = {"id": article_id}
article = articleRepository.load(**kwargs)
if not article:
return Response({"status": 400, "msg": "文章不存在"})
utc_time = TimeUtil.get_utc_time()
catalog_type = data.get("catalog_type")
workspace = WorkspaceUtil.get_workspace(request)
passport_id = workspace.passport_id
message = Message()
message.reply_id = passport_id
message.reply_name = workspace.name
message.passport_id = article.passport_id
message.article_id = article.id
message.article_title = article.title
message.created = utc_time
message.status = 0
message.reply_type = Message.Type.reply.value
flag = True
if parent_id == 0:
message.reply_type = Message.Type.answer.value
if article.passport_id == passport_id:
flag = False
# 判断是否有根节点存在
kwargs = {}
kwargs["layer"] = 0
kwargs["article_id"] = article_id
catalog_res = commentRepository.load(**kwargs)
# 根节点不存在 先创建一个根节点
if not catalog_res:
catalog = Comment()
catalog.passport_id = passport_id
catalog.parent_id = 0
catalog.layer = 0
catalog.left_id = 1
catalog.right_id = 4
catalog.content = ""
catalog.catalog_type = catalog_type
catalog.version = 1
catalog.created = utc_time
catalog.article_id = article_id
catalog.save()
catalog_id = catalog.id
catalog = Comment()
catalog.parent_id = catalog_id
catalog.layer = 1
catalog.left_id = 2
catalog.right_id = 3
catalog.content = data["content"]
catalog.passport_id = passport_id
catalog.catalog_type = catalog_type
catalog.article_id = article_id
catalog.version = 1
catalog.created = utc_time
catalog.save()
else:
# 更新需要更新的左节点
kwargs = {}
kwargs["catalog_type"] = catalog_type
kwargs["right_id"] = catalog_res.right_id
commentRepository.update_left_id(**kwargs)
# 更新需要更新的右节点
commentRepository.update_right_id(**kwargs)
parent_id = catalog_res.id
catalog = Comment()
catalog.parent_id = parent_id
catalog.layer = catalog_res.layer + 1
catalog.left_id = catalog_res.right_id
catalog.right_id = catalog_res.right_id + 1
catalog.catalog_type = catalog_type
catalog.passport_id = passport_id
catalog.article_id = article_id
catalog.content = data["content"]
catalog.version = 1
catalog.created = utc_time
catalog.save()
else:
# 新增节点
kwargs = {}
kwargs["id"] = parent_id
catalog_res = commentRepository.load(**kwargs)
message.passport_id = catalog_res.passport_id
if catalog_res.passport_id == passport_id:
flag = False
# 更新需要更新的左节点
kwargs = {}
kwargs["catalog_type"] = catalog_res.catalog_type
kwargs["right_id"] = catalog_res.right_id
commentRepository.update_left_id(**kwargs)
# 更新需要更新的右节点
commentRepository.update_right_id(**kwargs)
catalog = Comment()
catalog.parent_id = parent_id
catalog.layer = catalog_res.layer + 1
catalog.left_id = catalog_res.right_id
catalog.right_id = catalog_res.right_id + 1
catalog.passport_id = passport_id
catalog.article_id = article_id
catalog.catalog_type = catalog_res.catalog_type
catalog.content = data["content"]
catalog.version = 1
catalog.created = utc_time
catalog.save()
catalog = CommentSerializers(catalog).data
if flag:
message.save()
return Response({"status": 200, "msg": "新增评论成功", "data": catalog})
def __deco(request):
token = request.META.get("HTTP_AUTHORIZATION")
if sign:
if not token:
return Response({"status": 401, "msg": "请先登录"})
# 先从缓存获取token是否存在
token = token.split(" ")[1]
token_info = cache.get(token)
if not token_info:
# 从数据库查询
kwargs = {}
kwargs["token_id"] = token
token_info = tokenRepository.load(**kwargs)
if not token_info or token_info.expire_time < TimeUtil.get_utc_time(
):
return Response({"status": 401, "msg": "请先登录"})
expire_time = settings.webExpireTime
if token_info.login_type == Token.LoginType.app.value:
expire_time = settings.appExpireTime
token_info.start_time = TimeUtil.get_utc_time()
token_info.expire_time = TimeUtil.get_utc_time(
) + expire_time
token_info.save()
workspace = WorkspaceUtil.get_workspace_by_token(
token_info)
cache.set(token_info.token_id,
workspace,
timeout=expire_time)
else:
# 更新缓存过期时间
expire_time = settings.webExpireTime
if token_info.login_type == Token.LoginType.app.value:
expire_time = settings.appExpireTime
token_info.expire_time = TimeUtil.get_utc_time(
) + expire_time
token_info.start_time = TimeUtil.get_utc_time()
cache.set(token, token_info, timeout=expire_time)
result = signature(request)
if not result:
return Response({"status": 401, "msg": "签名错误"})
else:
# 不需要登录的接口 更新token过期时间
if token:
token = token.split(" ")[1]
token_info = cache.get(token)
if not token_info:
# 从数据库查询, 如果存在更新过期时间
kwargs = {}
kwargs["token_id"] = token
token_info = tokenRepository.load(**kwargs)
if token_info:
# 判断token 是否过期
if token_info.expire_time > TimeUtil.get_utc_time(
):
print(11111)
expire_time = settings.webExpireTime
if token_info.login_type == Token.LoginType.app.value:
expire_time = settings.appExpireTime
token_info.start_time = TimeUtil.get_utc_time()
token_info.expire_time = TimeUtil.get_utc_time(
) + expire_time
token_info.save()
workspace = WorkspaceUtil.get_workspace_by_token(
token_info)
cache.set(token_info.token_id,
workspace,
timeout=expire_time)
else:
print(22222)
return func(request)
