async def get(self, *args, **kwargs):
"""
获取评论下的回复列表
:param args:
:param kwargs:
:return:
"""
res_data = []
comment_id = self.get_argument("comment_id", None)
per_page = self.get_argument("per_page", 10)
page = self.get_argument("page", 1)
per_page = get_int_or_none(per_page)
page = get_int_or_none(page)
if not all([page, per_page]):
self.set_status(400)
res_data["content"] = "page 或者 per_page参数不合法"
try:
comment_obj = await self.application.objects.get(
Comment, id=get_int_or_none(comment_id))
reply_query = Reply.select().where(Reply.comment == comment_obj)
reply_query = reply_query.limit(per_page).offset(
(page - 1) * per_page)
reply_objs = await self.application.objects.execute(reply_query)
for reply_obj in reply_objs:
reply_dict = {}
reply_dict["id"] = reply_obj.id
reply_dict["user_id"] = reply_obj.user_id
reply_dict["content"] = reply_obj.content
res_data.append(reply_dict)
except Exception:
self.set_status(400)
res_data["content"] = "评论不存在"
self.finish(json.dumps(res_data))
async def get(self, *args, **kwargs):
"""
获取帖子下的评论列表
:param args:
:param kwargs:
:return:
"""
res_data = []
post_id = self.get_argument("post_id", None)
per_page = self.get_argument("per_page", 10)
page = self.get_argument("page", 1)
per_page = get_int_or_none(per_page)
page = get_int_or_none(page)
if not all([page, per_page]):
self.set_status(400)
self.write("page 或者 per_page参数不合法")
try:
post_obj = await self.application.objects.get(
CommunityPost, id=get_int_or_none(post_id))
comment_query = Comment.select().where(Comment.post == post_obj)
comment_query = comment_query.limit(per_page).offset(
(page - 1) * per_page)
comment_objs = await self.application.objects.execute(comment_query
)
for comment_obj in comment_objs:
comment_dict = {}
comment_dict["id"] = comment_obj.id
comment_dict["user_id"] = comment_obj.user_id
comment_dict["content"] = comment_obj.content
res_data.append(comment_dict)
except Exception:
self.set_status(400)
self.write("帖子不存在")
self.finish(json.dumps(res_data))
async def get(self, *args, **kwargs):
"""
获取帖子列表、搜索
:param args:
:param kwargs:
:return:
"""
res_data = []
group_id = self.get_argument("group_id", None)
try:
group = await self.application.objects.get(
CommunityGroup, id=get_int_or_none(group_id))
await self.application.objects.get(CommunityGroupMember,
user=self.current_user,
group=group,
status=1)
except Exception:
self.set_status(400)
self.write("小组不存在或用户未成功加入小组")
posts_query = CommunityPost.select()
hot = self.get_argument("hot", None)
if hot:
posts_query = posts_query.filter(CommunityPost.is_hot == True)
cream = self.get_argument("cream", None)
if cream:
posts_query = posts_query.filter(CommunityPost.is_cream == True)
per_page = self.get_argument("per_page", 10)
page = self.get_argument("page", 1)
per_page = get_int_or_none(per_page)
page = get_int_or_none(page)
if not all([page, per_page]):
self.set_status(400)
self.write("page 或者 per_page参数不合法")
posts_query = posts_query.limit(per_page).offset((page - 1) * per_page)
post_objs = await self.application.objects.execute(posts_query)
for post_obj in post_objs:
post_dict = {}
post_dict["id"] = post_obj.id
post_dict["user_id"] = post_obj.user_id
post_dict["title"] = post_obj.title
post_dict["content"] = post_obj.content
res_data.append(post_dict)
self.finish(json.dumps(res_data))
async def get(self, *args, **kwargs):
"""
根据group id 获取小组详情
:param args:
:param kwargs:
:return:
"""
res_data = {}
group_id = get_int_or_none(self.get_argument("group_id", None))
if not group_id:
self.set_status(400)
self.write({"content": "缺少group_id参数"})
try:
group_obj = await self.application.objects.get(CommunityGroup,
id=group_id)
res_data["id"] = group_id
res_data["name"] = group_obj.name
res_data["description"] = group_obj.description
res_data["notice"] = group_obj.notice
res_data["member_nums"] = group_obj.member_nums
res_data["post_nums"] = group_obj.post_nums
res_data["front_image"] = "{}/media/{}/".format(
self.settings["SITE_URL"], group_obj.front_image)
self.write(res_data)
except CommunityGroup.DoesNotExist:
self.set_status(400)
self.write({"content": "group 不存在"})
async def post(self, *args, **kwargs):
res_data = {}
req_data = json.loads(self.request.body.decode("utf8"))
group_id = get_int_or_none(req_data.get("group_id"))
group = None
if not group_id:
self.set_status(400)
self.write("缺少group_id参数")
else:
try:
group = await self.application.objects.get(CommunityGroup,
id=group_id)
await self.application.objects.get(CommunityGroupMember,
user=self.current_user,
status=1)
except Exception:
self.set_status(400)
self.write("group_id不存在或该成员未加入小组")
post_form = PostForm.from_json(req_data)
if post_form.validate():
post_obj = await self.application.objects.create(
CommunityPost,
user=self.current_user,
title=post_form.title.data,
content=post_form.content.data,
group=group)
res_data["id"] = post_obj.id
else:
res_data = post_form.errors
self.finish(res_data)
async def post(self, *args, **kwargs):
"""
申请加入小组
:param args:
:param kwargs:
:return:
"""
res_data = {}
req_data = self.request.body.decode("utf8")
req_data = json.loads(req_data)
group_id = get_int_or_none(req_data.get("group_id"))
group_member_form = GroupMemberForm.from_json(req_data)
if group_member_form.validate():
try:
await self.application.objects.get(CommunityGroup, id=group_id)
await self.application.objects.get(CommunityGroupMember,
user=self.current_user,
group=group_id)
self.set_status(400)
res_data["content"] = "请勿重复申请"
except CommunityGroup.DoesNotExist:
self.set_status(404)
except CommunityGroupMember.DoesNotExist:
group_member_obj = await self.application.objects.create(
CommunityGroupMember,
user=self.current_user,
group=group_id,
apply_reason=group_member_form.apply_reason.data)
res_data["id"] = group_member_obj.id
res_data["content"] = "申请成功，等待审核"
else:
self.set_status(400)
res_data = group_member_form.errors
self.finish(res_data)
async def get(self, answer_id, *args, **kwargs):
"""
通过回复的答案ID获取其评论信息
:param answer_id:
:param args:
:param kwargs:
:return:
"""
res_data = []
answer_replys = await self.application.objects.execute(
Answer.extend().where(
Answer.parent_answer == get_int_or_none(answer_id)))
for item in answer_replys:
item_dict = {
"user": model_to_dict(item.user),
"content": item.content,
"reply_nums": item.reply_nums,
"add_time": item.add_time.strftime("%Y-%m-%d"),
"id": item.id
}
res_data.append(item_dict)
self.write(json.dumps(res_data))
async def post(self, question_id, *args, **kwargs):
# 新增评论
res_data = {}
param = self.request.body.decode("utf8")
param = json.loads(param)
form = AnswerForm.from_json(param)
if form.validate():
try:
question_obj = await self.application.objects.get(
Question, id=get_int_or_none(question_id))
answer_obj = await self.application.objects.create(
Answer,
user=self.current_user,
question=question_obj,
content=form.content.data)
question_obj.answer_nums += 1
await self.application.objects.update(question_obj)
res_data["id"] = answer_obj.id
res_data["user"] = {
"nick_name": self.current_user.nick_name,
"id": self.current_user.id
}
except Question.DoesNotExist as e:
self.set_status(404)
else:
self.set_status(400)
for field in form.errors:
res_data[field] = form.errors[field][0]
self.finish(res_data)
async def get(self, question_id, *args, **kwargs):
"""
获取某个问题的所有回答
:param question_id:
:param args:
:param kwargs:
:return:
"""
res_data = []
try:
question_obj = await self.application.objects.get(
Question, id=get_int_or_none(question_id))
answer_objs = await self.application.objects.execute(
Answer.extend().where(
Answer.question == question_obj,
Answer.parent_answer.is_null(True)).order_by(
Answer.create_time.desc()))
for item in answer_objs:
item_dict = {
"user": model_to_dict(item.user),
"content": item.content,
"reply_nums": item.reply_nums,
"id": item.id,
}
res_data.append(item_dict)
except Question.DoesNotExist as e:
self.set_status(404)
self.write(json.dumps(res_data))
async def get(self, *args, **kwargs):
"""
获取小组列表、搜索
:param args:
:param kwargs:
:return:
"""
res_data = []
community_query = CommunityGroup.extend()
# 根据类别进行过滤
category = self.get_argument("category", None)
if category:
community_query = community_query.filter(
CommunityGroup.category == category)
# 根据参数进行排序
order = self.get_argument("o", None)
if order:
if order == "new":
community_query = community_query.order_by(
CommunityGroup.create_time.desc())
elif order == "hot":
community_query = community_query.order_by(
CommunityGroup.member_nums.desc())
per_page = self.get_argument("per_page", 10)
page = self.get_argument("page", 1)
per_page = get_int_or_none(per_page)
page = get_int_or_none(page)
if not all([page, per_page]):
self.set_status(400)
self.write("page 或者 per_page参数不合法")
community_query = community_query.limit(per_page).offset(
(page - 1) * per_page)
group_objs = await self.application.objects.execute(community_query)
for group_obj in group_objs:
group_dict = model_to_dict(group_obj)
group_dict["front_image"] = "{}/media/{}/".format(
self.settings["SITE_URL"], group_dict["front_image"])
res_data.append(group_dict)
self.finish(json.dumps(res_data))
async def get(self, *args, **kwargs):
"""
获取小组帖子详情
:param args:
:param kwargs:
:return:
"""
res_data = {}
group_id = get_int_or_none(self.get_argument("group_id", None))
if not group_id:
self.set_status(400)
self.write({"content": "缺少group_id参数"})
try:
group_obj = await self.application.objects.get(CommunityGroup,
id=group_id)
await self.application.objects.get(CommunityGroupMember,
group=group_obj,
user=self.current_user)
except Exception:
self.set_status(400)
self.write({"content": "group 不存在或用户尚未加入该小组"})
post_id = get_int_or_none(self.get_argument("id", None))
if not post_id:
self.set_status(400)
self.write("缺少id参数")
try:
post_obj = await self.application.objects.get(CommunityPost,
id=post_id)
res_data["id"] = post_id
res_data["title"] = post_obj.title
res_data["content"] = post_obj.content
res_data["is_hot"] = post_obj.is_hot
res_data["is_cream"] = post_obj.is_cream
except CommunityPost.DoesNotExist:
self.set_status(400)
res_data["content"] = "帖子不存在"
self.finish(res_data)
async def post(self, answer_id, *args, **kwargs):
"""
添加回复
:param answer_id:
:param args:
:param kwargs:
:return:
"""
res_data = {}
param = self.request.body.decode("utf8")
param = json.loads(param)
form = AnswerReplyForm.from_json(param)
if form.validate():
try:
answer = await self.application.objects.get(
Answer, id=get_int_or_none(answer_id))
replyed_user = await self.application.objects.get(
User, id=form.replyed_user.data)
reply = await self.application.objects.create(
Answer,
user=self.current_user,
parent_answer=answer,
reply_user=replyed_user,
content=form.content.data)
# 修改comment的回复数
answer.reply_nums += 1
await self.application.objects.update(answer)
res_data["id"] = reply.id
res_data["user"] = {
"id": self.current_user.id,
"nick_name": self.current_user.nick_name
}
except Answer.DoesNotExist as e:
self.set_status(404)
except User.DoesNotExist as e:
self.set_status(400)
res_data["replyed_user"] = "******"
else:
self.set_status(400)
for field in form.errors:
res_data[field] = form.errors[field][0]
self.write(res_data)
async def get(self, *args, **kwargs):
"""
通过订单生成支付链接
:param args:
:param kwargs:
:return:
"""
res_data = {}
order_id = get_int_or_none(self.get_argument("id", None))
if not order_id:
self.set_status(400)
self.write({"content": "缺少order_id参数"})
try:
order_obj = await self.application.objects.get(
OrderInfo, id=order_id,
pay_status=OrderInfo.ORDER_STATUS[4][0]
)
out_trade_no = order_obj.order_sn
order_mount = order_obj.order_mount
subject = order_obj.post_script
alipay = AliPay(
appid=settings["ALI_APPID"],
app_notify_url="{}/alipay/return/".format(settings["SITE_URL"]),
app_private_key_path=settings["private_key_path"],
alipay_public_key_path=settings["ali_pub_key_path"],
debug=True,
return_url="{}/alipay/return/".format(settings["SITE_URL"])
)
url = alipay.direct_pay(
subject=subject,
out_trade_no=out_trade_no,
total_amount=order_mount,
return_url="{}/alipay/return/".format(settings["SITE_URL"])
)
re_url = settings["RETURN_URI"].format(data=url)
res_data["re_url"] = re_url
except OrderInfo.DoesNotExist:
self.set_status(400)
res_data["content"] = "订单不存在"
self.finish(res_data)
async def get(self, question_id, *args, **kwargs):
"""
根据question id 获取问题详情
:param question_id:
:param args:
:param kwargs:
:return:
"""
question_details = await self.application.objects.execute(
Question.extend().where(
Question.id == get_int_or_none(question_id)))
if not question_details:
self.set_status(404)
item_dict = model_to_dict(question_details[0])
item_dict["image"] = "{}/media/{}/".format(self.settings["SITE_URL"],
item_dict["image"])
res_data = item_dict
self.write(json.dumps(res_data))
