def user_Operation(request):
data = request.data
id = data.get("id")
target_id = data.get("target_id")
operation_type = data.get("type")
if id and target_id:
if id == target_id:
return restful.fail(message="id == targetid ,操作失败")
if operation_type not in Relation_Detail.RELATION_CHOICES:
return restful.fail(message="错误的操作类型")
try:
user = User.objects.get(pk=id)
target_user = User.objects.get(pk=target_id)
relation_detail = Relation_Detail.objects.filter(who_relation=user,relation_who=target_user).first()
if not relation_detail:
relation_detail = Relation_Detail.objects.create(who_relation=user,relation_who=target_user,relation_type=operation_type)
return restful.ok(message="修改成功")
relation_detail.relation_type = operation_type
relation_detail.save()
if relation_detail.relation_type == 0:
relation_detail.delete()
return restful.ok(message="修改成功")
except:
return restful.fail(message="用户不存在")
else:
logger = logging.getLogger('stu')
logger.info('url:%s method:%s 成功'% (request.path, request.method))
return restful.fail(message="传入参数错误")
def get_BlackList(request):
id = request.data.get("id")
pagenum = request.data.get("pagenum")
pagesize = request.data.get("pagesize")
if id and pagenum and pagesize:
try:
user = User.objects.get(pk=id)
except:
return restful.fail(message="用户不存在")
blacked_user = Relation_Detail.objects.filter(who_relation=user,relation_type=-1).all()[(pagenum- 1) * pagesize : (pagenum- 1) * pagesize + pagesize]
print(blacked_user)
serializer = ListUserReturnSerializer(blacked_user,many=True)
print(serializer.data)
data = {}
data['users'] = serializer.data
for dict_item in data['users']:
dict_item['time'] = dict_item.pop("date_relation")
dict_pop = dict_item.pop("relation_who")
dict_item["name"] = dict_pop["username"]
dict_item["avatar"] = dict_pop["avatar"]
dict_item["id"] = dict_pop["id"]
return restful.ok(message="成功",data=data)
else:
return restful.fail(message="传入参数错误") # 未考虑page
def comment_Blog(request):
data = request.data
blog_id = data.get("id")
user_id = data.get("user_id")
to_user_id = data.get("to_user_id")
text = data.get("text")
try:
blog = Article.objects.get(pk=blog_id)
except:
return restful.fail(message="博文不存在")
try:
to_user = User.objects.get(pk=to_user_id)
user = User.objects.get(pk=user_id)
except:
return restful.fail(message="用户不存在")
blacked_users = Relation_Detail.objects.filter(who_relation=to_user,relation_type=-1).all()
for blacked_user in blacked_users.all():
if user == blacked_user.relation_who:
return restful.fail(message="被拉黑用户不能评论")
comment = Comment.objects.create(content=text,article=blog,author=user,to_user=to_user.id)
comment_count = blog.comment_count
blog.comment_count = comment_count + 1
blog.save()
return restful.ok(message="评论成功")
def recommend_Blog(request):
blog_id = request.data.get("blog_id")
user_id = request.data.get("user_id")
operation_type = request.data.get("recommend")
if blog_id and user_id:
try:
user = User.objects.get(pk=user_id)
blog = Article.objects.get(pk=blog_id)
except:
return restful.fail(message="用户或博文不存在")
is_exist = Recommand_Detail.objects.filter(user=user,article=blog).first()
if operation_type == 0:
# 取消推荐
if not is_exist:
return restful.fail(message="用户尚未推荐该博文")
is_exist.delete()
return restful.ok(message="取消推荐成功")
elif operation_type == 1:
# 推荐
if is_exist:
return restful.fail(message="不能重复推荐")
recommand_detail = Recommand_Detail.objects.create(user=user,article=blog)
return restful.ok(message="推荐成功")
else:
return restful.fail(message="错误的操作类型")
else:
return restful.fail(message="传入参数错误")
def delete_Blog(request):
data = request.data
user_id = data.get("user_id")
blog_id = data.get("blog_id")
if user_id and blog_id:
try:
blog = Article.objects.get(pk=blog_id)
user = User.objects.get(pk=user_id)
except:
return restful.fail(message="博文或用户不存在")
auth_id = blog.author.id
if user.is_superuser or auth_id == user_id:
# 删除博文 tag.count 含义是当前标签下的参与人数
print(blog.category.all())
for tag in blog.category.all():
articles = Article.objects.filter(category=tag).exclude(
id=blog_id)
user_in = User.objects.filter(article__in=articles).all()
print("user_in:", user_in)
print("now count:", tag.count)
if not user in user_in:
tag.count -= 1
tag.save()
print("end count:", tag.count)
if tag.count == 0:
tag.delete()
blog.delete()
return restful.ok(message="删除成功")
else:
# 提示没有权限
return restful.fail(message="用户没有权限，删除失败")
else:
return restful.fail(message="参数格式错误")
def change_Password(request):
email = request.data.get("email")
if email:
user = User.objects.filter(email=email).first()
if user:
return restful.ok(message="邮箱存在")
else:
return restful.fail(message="用户不存在")
else:
return restful.fail(message="请传入emaill")
def online(request):
try:
data = json.loads(request.body)
skl_id = data['skl_id']
model_id = data['model_id']
res = online_model(model_id, skl_id)
except:
return fail()
else:
if res:
return success()
else:
return fail()
def get_commentList(request):
id = request.data.get("id") # 博文id
pagenum = request.data.get("pagenum")
pagesize = request.data.get("pagesize")
try:
blog = Article.objects.get(pk=id)
except:
return restful.fail(message="博文不存在")
comments = blog.comments.all().order_by('pub_time')[(pagenum- 1) * pagesize : (pagenum- 1) * pagesize + pagesize]
serializer = CommentSerializer(comments,many=True)
data = serializer.data
to_user = []
index = 0
count = comments.count()
for index in range(0,count):
to_user.append(comments[index].to_user)
print(comments[index].to_user)
index = 0
for dict_item in data:
dict_item.pop("article").pop("author")
user_item = User.objects.get(pk=to_user[index])
dict_item["to_user"] = {}
dict_item["to_user"]["id"] = user_item.id
dict_item["to_user"]["name"] = user_item.username
index += 1
dict_item["user"] = dict_item.pop("author")
print(data)
for data_item in data:
data_item['user']['name'] = data_item['user'].pop('username')
return_data = {}
return_data['list'] = data
return restful.ok(message="操作成功",data=return_data)
def get_recommend_list(request):
id = request.data.get("id") # 用户id
pagenum = request.data.get("pagenum")
pagesize = request.data.get("pagesize")
try:
user = User.objects.get(pk=id)
except:
return restful.fail(message="用户不存在")
# 当前用户关注的
focus_user = User.objects.filter(Q(relation_who_set__relation_type=1) & Q(relation_who_set__who_relation=user))
hate_user = User.objects.filter(relation_who_set__who_relation=user,relation_who_set__relation_type=-1)
focus_user_id = []
for user_item in focus_user:
focus_user_id.append(user_item.id)
hate_user_id = []
for user_item in hate_user:
hate_user_id.append(user_item.id)
hate_user_id.append(id)
recommend_user = User.objects.filter(Q(relation_who_set__relation_type=1) & Q(relation_who_set__who_relation__in=focus_user) & ~Q(id__in=hate_user_id) & ~Q(id__in=focus_user_id))
if len(recommend_user) == 0:
recommend_user = User.objects.filter(~Q(id__in=hate_user)).all()
user_recommend_id = []
for recommend_item in recommend_user:
user_recommend_id.append(recommend_item.id)
recommend_user = User.objects.filter(~Q(id=id) & Q(id__in=user_recommend_id) ).order_by('?')[(pagenum- 1) * pagesize : (pagenum- 1) * pagesize + pagesize]
total = recommend_user.count()
#print("recommend_user.count:",recommend_user.count())
recommend_list_serializer = RecommendList_Serializer(recommend_user,many=True)
data = recommend_list_serializer.data
#print("data:",data)
return_data = {}
return_data['total'] = total
for user_item in data:
data_tags = {}
user_item['name'] = user_item.pop("username")
for data_item in user_item.get("article_set"):
data_tags = data_item.pop("category")
user_item["tags"] = data_tags
if user_item["tags"] and len(user_item["tags"]) > 5:
user_item["tags"] = user_item["tags"][0:5]
user_item["blogs"] = user_item.pop("article_set")
if user_item["blogs"] and len(user_item["blogs"]) > 4:
user_item["blogs"] = user_item["blogs"][0:1]
tag_name = []
for tag in user_item['tags']:
tag_name.append(tag['name'])
user_item['tags'] = tag_name
return_data['users'] = data
return restful.ok(message="操作成功",data=return_data)
# [(pagenum- 1) * pagesize : (pagenum- 1) * pagesize + pagesize]
def search_User(request):
id = request.data.get("id") # 用户id
pagenum = request.data.get("pagenum")
pagesize = request.data.get("pagesize")
key_word = request.data.get("search")
if id and key_word:
try:
user = User.objects.get(pk=id)
except:
return restful.fail(message="用户不存在")
blacked_user = Relation_Detail.objects.filter(who_relation=user,relation_type=-1).all()
blacked_id = []
for blacked_user_item in blacked_user:
blacked_id.append(blacked_user_item.relation_who.id)
# print(blacked_id)
# 查询出来的用户
users_all = User.objects.filter(Q(username__icontains=key_word) & ~Q(id=id)).exclude(id__in=blacked_id).all()
users = users_all[(pagenum- 1) * pagesize : (pagenum- 1) * pagesize + pagesize]
total = users_all.count()
serializer = Relation_Time_Serializer(users,many=True)
data = serializer.data
return_data = {}
return_data["total"] = total
for dict_item in data:
id_dict = dict_item["id"]
last_article = Article.objects.filter(author__id=id_dict).all()
if last_article:
pub_time = last_article.order_by('-pub_time').first().pub_time
dict_item["time"] = pub_time
else:
print("None error for test")
dict_item["time"] = None
is_focus = Relation_Detail.objects.filter(who_relation=user,relation_who__id=id_dict,relation_type=1).first()
if is_focus:
dict_item["isFocused"] = 1
else:
dict_item["isFocused"] = 0
return_data["users"] = data
return restful.ok(message="操作成功",data=return_data)
else:
return restful.fail(message="传入参数错误")
def register_View(request):
serializer = RegisterSerializer(data=request.data)
if serializer.is_valid():
username = serializer.data.get("name")
password = serializer.data.get("password")
email = serializer.data.get("email")
user = User.objects.create_user(email=email,username=username,password=password)
login(request,user)
return restful.ok(message="注册成功")
else:
print(serializer.errors)
return restful.fail(message=serializer.errors)
def login_View(request):
data = request.data
serializer = LoginSerializer(data=data)
if serializer.is_valid():
email = data.get('email')
password = data.get('password')
user = authenticate(request,username=email,password=password)
if user:
if user.is_active:
return_serializer = LoginReturnSerializer(user)
data = return_serializer.data
data.update({"name":data.pop("username")})
print(data)
login(request,user)
return restful.ok(data=data,message="")
else:
return restful.fail(message="用户已被限制登录")
else:
return restful.fail(message="账号或密码错误")
else:
print(serializer.errors)
return restful.fail(message="输入信息格式不符")
def get_FocusList(request):
id = request.data.get("id")
pagenum = request.data.get("pagenum")
pagesize = request.data.get("pagesize")
orderType = request.data.get("orderType")
search = request.data.get('search')
if id and pagenum and pagesize:
try:
user = User.objects.get(pk=id)
except:
return restful.fail(message="用户不存在")
focused_user = Relation_Detail.objects.filter(Q(who_relation=user) & (Q(relation_type=1) | Q(relation_type=2)) & Q(relation_who__username__icontains=search)).all()
print(focused_user)
if orderType == 0 :
focused_user = focused_user[(pagenum- 1) * pagesize : (pagenum- 1) * pagesize + pagesize]
print(focused_user)
elif orderType == 1:
focused_user = focused_user.order_by("-date_relation").all()[(pagenum- 1) * pagesize : (pagenum- 1) * pagesize + pagesize]
else:
return restful.fail("没有指定的排序类型")
serializer = ListUserReturnSerializer(focused_user,many=True)
data = {}
data['users'] = serializer.data
data['total'] = focused_user.count()
for dict_item in data['users']:
dict_item['time'] = dict_item.pop("date_relation")
dict_pop = dict_item.pop("relation_who")
dict_item["name"] = dict_pop["username"]
dict_item["avatar"] = dict_pop["avatar"]
dict_item["id"] = dict_pop["id"]
return restful.ok(message="成功",data=data)
else:
return restful.fail(message="传入参数错误")
def update_View(request):
print(request.data)
serializer = UpdateSerializer(data=request.data)
if serializer.is_valid():
print(serializer.data)
pk = serializer.data.get("id")
print(type(pk))
name = serializer.data.get("name")
email = serializer.data.get("email")
avatar = serializer.data.get("avatar")
password = serializer.data.get("password")
try:
tag = 0
user = User.objects.get(pk=pk)
if user:
if name:
user.username = name
tag = 1
if email:
user.email = email
tag = 1
if avatar:
user.avatar = avatar
tag = 1
if password:
user.set_password(password)
tag = 1
if tag == 0 :
return restful.fail(message="未传入任何需要修改的信息")
user.save()
return restful.ok(message="修改成功")
except:
return restful.fail(message="用户不存在")
else:
if serializer.errors.get("email"):
return restful.fail(message="邮箱格式错误或已被注册")
return restful.fail(message="传入参数格式有误")
def get_hostList(request):
id = request.data.get("id") # 博文id
pagenum = request.data.get("pagenum")
pagesize = request.data.get("pagesize")
if id:
try:
blog = Article.objects.get(pk=id)
except:
return restful.fail(message="博文不存在")
like_users = User.objects.filter(like_detail__article=blog).all()
serializer = Return_User_Serializer(like_users,many=True)
data_like = serializer.data.copy()
for data_item in data_like:
data_item['type'] = 0
recommend_users = User.objects.filter(recommand_detail__article=blog).all()[(pagenum- 1) * pagesize : (pagenum- 1) * pagesize + pagesize]
serializer_recommend = Return_User_Serializer(recommend_users,many=True)
data_recommend = serializer_recommend.data.copy()
for data_item in data_recommend:
data_item['type'] = 1
print(data_recommend)
print(data_like)
data = data_like + data_recommend
for data_item in data:
data_item['name'] = data_item.pop("username")
return_data = {}
return_data['list'] = data
return restful.ok(message="操作成功",data=return_data)
else:
return restful.fail(message="传入参数错误")
def vist_tag(request):
name = request.data.get("name")
if name:
tag = ArticleCategory.objects.filter(name=name).first()
if not tag:
data = {}
data['count'] = 0
return restful.ok(data=data)
tag.count += 1
tag.save()
data = {}
data['count'] = tag.count
return restful.ok(message="访问成功", data=data)
else:
return restful.fail(message="请传入标签名称")
def train(request):
try:
data = json.loads(request.body)
skl_id = data['skl_id']
# 判断是否为第一次训练
first = not Model.objects.filter(skill_id=skl_id).exists()
# 生成配置文件
# create_config_file(skl_id, first)
# 保存到数据库
version = save_model(skl_id, first)
# 生成训练任务
tasks.train_model.delay(
version, skl_id,
os.path.join(MODEL_DIR, str(skl_id), 'train_log.txt'))
except:
return fail()
else:
result = {"version": version}
return success(result)
def get_user_Detail(request):
id = request.data.get("id")
now_id = request.data.get("nowUser")
try:
user = User.objects.get(pk=id)
now_user = User.objects.get(pk=now_id)
except:
return restful.fail(message="用户不存在")
blog_count = user.article_set.all().count()
follow_count = Relation_Detail.objects.filter(relation_who=user,relation_type=1).all().count()
serializer = UserSerializer(user)
data = serializer.data
data["blogCount"] = blog_count
data["focusCount"] = follow_count
if id != now_id:
is_focus = Relation_Detail.objects.filter(relation_who=user,who_relation=now_user,relation_type=1).first()
if is_focus:
data["isFocused"] = 1
else:
data["isFocused"] = 0
return restful.ok(message="操作成功",data=data)
def get_tagList(request):
pagenum = request.data.get("pagenum")
pagesize = request.data.get("pagesize")
type_operation = request.data.get("type")
if type_operation == 0: # 热门
tags = ArticleCategory.objects.all().order_by("count")[
(pagenum - 1) * pagesize:(pagenum - 1) * pagesize + pagesize]
serializer = TagSerializer(tags, many=True)
elif type_operation == 1: # 最新
tags = ArticleCategory.objects.all().order_by("-time")[
(pagenum - 1) * pagesize:(pagenum - 1) * pagesize + pagesize]
serializer = TagSerializer(tags, many=True)
else:
return restful.fail(message="传入参数错误")
data = {}
data["tags"] = []
for tag_item in serializer.data:
data["tags"].append(tag_item["name"])
data["total"] = ArticleCategory.objects.aggregate(
Count("name")).get("name__count")
return restful.ok(message="操作成功", data=data)
def get_tag_UerList(request):
id = request.data.get("id") # 用户id
pagenum = request.data.get("pagenum")
pagesize = request.data.get("pagesize")
name = request.data.get("name") # 便签名
if id and name:
try:
user = User.objects.get(pk=id)
tag = ArticleCategory.objects.get(name=name)
except:
data = {}
data['users'] = []
return restful.ok(message="用户或便签不存在", data=data)
related_users = User.objects.filter(
Q(article__category=tag)
& ~Q(id=id)).distinct()[(pagenum - 1) *
pagesize:(pagenum - 1) * pagesize +
pagesize]
serializer = Return_User_Serializer(related_users, many=True)
#focused_user = Relation_Detail.objects.filter(who_relation=user,relation_type=1).all()
data = serializer.data
for dict_item in data:
id_dict = dict_item["id"]
is_focus = Relation_Detail.objects.filter(who_relation=user,
relation_who__id=id_dict,
relation_type=1).first()
if is_focus:
dict_item["isFocused"] = 1
else:
dict_item["isFocused"] = 0
return_data = {}
return_data['users'] = data
return restful.ok(message="成功", data=return_data)
else:
return restful.fail(message="传入参数错误")
def like_Blog(request):
data = request.data
blog_id = data.get("blog_id")
user_id = data.get("user_id")
love = data.get("love")
if blog_id and user_id:
try:
user = User.objects.get(pk=user_id)
except:
return restful.fail(message="用户不存在")
try:
blog = Article.objects.get(pk=blog_id)
except:
return restful.fail(message="博文不存在")
# 对博文进行操作
if blog.author == user:
return restful.fail(message="不能对自己的博文操作")
if love == 0:
like_detail = Like_Detail.objects.filter(user=user,article=blog).first()
if not like_detail:
return restful.fail(message="用户未对博文点赞，不能取消")
blog.like_count -= 1
blog.save()
like_detail.delete()
return restful.ok(message="取消点赞成功")
elif love == 1:
# 点赞
if blog in user.like.all():
return restful.fail(message="不能重复点赞")
like_detail = Like_Detail.objects.create(user=user,article=blog)
blog.like_count += 1
blog.save()
return restful.ok(message="点赞成功")
else:
return restful.fail(message="操作类型错误")
else:
return restful.fail(message="请传入博文id")
def get_blogList(request):
id = request.data.get("id")
isHome = request.data.get("isHome")
pagenum = request.data.get('pagenum')
pagesize = request.data.get("pagesize")
try:
user = User.objects.get(pk=id)
except:
return restful.fail(message="用户不存在")
if isHome == True: # 需要该用户的博文和关注用户发表和推荐的博文
focused_user = User.objects.filter(
(Q(relation_who_set__relation_type=1)
| Q(relation_who_set__relation_type=2))
& Q(relation_who_set__who_relation=user))
no_recommend_user = User.objects.filter(
relation_who_set__relation_type=2,
relation_who_set__who_relation=user)
print(focused_user)
focused_user_blog = Article.objects.filter(
~Q(author=user) & ~Q(author__in=no_recommend_user)
& (Q(author__in=focused_user)
| Q(recommand_detail__user__in=focused_user))).distinct(
).order_by("-pub_time")
# print(focused_user_blog.query)
print(focused_user_blog)
user_blog = Article.objects.filter(author=user).all().order_by(
"-pub_time") # 该用户的博文
serializer = BlogDetail_Serializer(focused_user_blog, many=True)
blog_data = serializer.data
index = 0
total = user_blog.count() + focused_user_blog.count()
# 关注用户发表和推荐的博文
for blog_data_item in blog_data:
blog_data_item["time"] = blog_data_item.pop("pub_time")
blog_data_item["pic"] = blog_data_item.pop("thumbnail")
blog_data_item['tags'] = blog_data_item.pop("category")
for tag_item in blog_data_item['tags']:
tag_item["isHot"] = tag_item.pop("is_great")
blog_data_item["user"] = blog_data_item.pop("author")
blog_data_item["user"]["name"] = blog_data_item["user"].pop(
"username")
blog_temp = focused_user_blog[index]
focused_user_item = focused_user.filter(
recommand_detail__article=blog_temp).first()
recommend_user_serializer = BlogDetail_Recommend_User_Serializer(
focused_user_item)
blog_data_item["referrer"] = recommend_user_serializer.data
blog_data_item["referrer"]["name"] = blog_data_item[
"referrer"].pop("username")
blog_data_item["commentCount"] = blog_data_item.pop(
"comment_count")
blog_data_item["picCount"] = 0 # 此处有问题!!!!
blog_temp = focused_user_blog[index]
blog_data_item[
"hotCount"] = blog_temp.like_count + Recommand_Detail.objects.filter(
article=blog_temp).count()
isLoved = Like_Detail.objects.filter(user=user,
article=blog_temp).first()
if isLoved:
blog_data_item["isLoved"] = 1
else:
blog_data_item["isLoved"] = 0
isReferred = Recommand_Detail.objects.filter(
user=user, article=blog_temp).first()
if isReferred:
blog_data_item["isReferred"] = 1
else:
blog_data_item["isReferred"] = 0
index += 1
#user_blog = Article.objects.filter(author=user).all() # 该用户的博文
own_serializer = BlogDetail_OwnBlog_Serializer(user_blog, many=True)
user_blog_data = own_serializer.data
for blog_data_item in user_blog_data:
blog_data_item["time"] = blog_data_item.pop("pub_time")
blog_data_item["pic"] = blog_data_item.pop("thumbnail")
blog_data_item['tags'] = blog_data_item.pop("category")
for tag_item in blog_data_item['tags']:
tag_item["isHot"] = tag_item.pop("is_great")
blog_data_item["user"] = blog_data_item.pop("author")
blog_data_item["user"]["name"] = blog_data_item["user"].pop(
"username")
blog_data_item["referrer"] = {}
blog_temp = Article.objects.get(pk=blog_data_item["id"])
blog_data_item["hotCount"] = Recommand_Detail.objects.filter(
article=blog_temp).count() + blog_temp.like_count
blog_data_item["commentCount"] = blog_data_item.pop(
"comment_count")
blog_data_item["picCount"] = 0 # 此处有问题!!!!
return_data = []
index_own = 0
index_focus = 0
while (index_own < len(blog_data)
and index_focus < len(user_blog_data)):
if blog_data[index_own]["time"] > user_blog_data[index_focus][
"time"]:
return_data.append(blog_data[index_own])
index_own += 1
else:
return_data.append(user_blog_data[index_focus])
index_focus += 1
for i in range(index_own, len(blog_data)):
return_data.append(blog_data[i])
for i in range(index_focus, len(user_blog_data)):
return_data.append(user_blog_data[i])
data = {}
data['blogs'] = return_data[(pagenum - 1) *
pagesize:(pagenum - 1) * pagesize +
pagesize]
#total = len(data['blogs'])
data['total'] = total
return restful.ok(message="操作成功", data=data)
else: #isHome=0 按照user_id和tag来筛选,目标关键词：博文标题或内容中存在的内容
tagType = request.data.get("tagType")
search = request.data.get("search")
user_id = request.data.get("user_id")
tag = request.data.get("tag")
if not search:
search = ""
if user_id:
user = User.objects.get(pk=user_id)
if tag:
blogs = Article.objects.filter(
Q(author__id=user_id) & Q(category__name=tag)
& (Q(text__icontains=search) | Q(title__icontains=search))
).all()[(pagenum - 1) * pagesize:(pagenum - 1) * pagesize +
pagesize]
print(blogs.query)
else:
blogs = Article.objects.filter(
Q(author__id=user_id)
& (Q(text__icontains=search) | Q(title__icontains=search))
).all()[(pagenum - 1) * pagesize:(pagenum - 1) * pagesize +
pagesize]
print(blogs.query)
total = blogs.count()
blogs_serializer = BlogDetail_OwnBlog_Serializer(blogs, many=True)
blog_data = blogs_serializer.data
data = {}
data['total'] = total
for blog_data_item in blog_data:
blog_data_item["time"] = blog_data_item.pop("pub_time")
blog_data_item["pic"] = blog_data_item.pop("thumbnail")
blog_data_item['tags'] = blog_data_item.pop("category")
for tag_item in blog_data_item['tags']:
tag_item["isHot"] = tag_item.pop("is_great")
blog_data_item["user"] = blog_data_item.pop("author")
blog_data_item["user"]["name"] = blog_data_item["user"].pop(
"username")
blog_data_item["commentCount"] = blog_data_item.pop(
"comment_count")
blog_data_item["picCount"] = 0 # 此处有问题!!!!
blog_temp = Article.objects.get(pk=blog_data_item["id"])
blog_data_item[
"hotCount"] = blog_temp.like_count + Recommand_Detail.objects.filter(
article=blog_temp).count()
if blog_temp.author.id != id:
isLoved = Like_Detail.objects.filter(
user=user, article=blog_temp).first()
if isLoved:
blog_data_item["isLoved"] = 1
else:
blog_data_item["isLoved"] = 0
isReferred = Recommand_Detail.objects.filter(
user=user, article=blog_temp).first()
if isReferred:
blog_data_item["isReferred"] = 1
else:
blog_data_item["isReferred"] = 0
data['blogs'] = blog_data
return restful.ok(message="操作成功", data=data)
else:
if tag:
blogs = Article.objects.filter(
Q(category__name=tag)
& (Q(text__icontains=search) | Q(title__icontains=search))
).all()[(pagenum - 1) * pagesize:(pagenum - 1) * pagesize +
pagesize]
print(blogs.query)
else:
blogs = Article.objects.filter(
(Q(text__icontains=search) | Q(title__icontains=search)
)).all()[(pagenum - 1) *
pagesize:(pagenum - 1) * pagesize + pagesize]
print(blogs.query)
total = blogs.count()
blogs_serializer = BlogDetail_OwnBlog_Serializer(blogs, many=True)
blog_data = blogs_serializer.data
data = {}
data['total'] = total
for blog_data_item in blog_data:
blog_data_item["time"] = blog_data_item.pop("pub_time")
blog_data_item["pic"] = blog_data_item.pop("thumbnail")
blog_data_item['tags'] = blog_data_item.pop("category")
for tag_item in blog_data_item['tags']:
tag_item["isHot"] = tag_item.pop("is_great")
blog_data_item["user"] = blog_data_item.pop("author")
blog_data_item["user"]["name"] = blog_data_item["user"].pop(
"username")
blog_data_item["commentCount"] = blog_data_item.pop(
"comment_count")
blog_data_item["picCount"] = 0 # 此处有问题!!!!
blog_temp = Article.objects.get(pk=blog_data_item["id"])
blog_data_item[
"hotCount"] = blog_temp.like_count + Recommand_Detail.objects.filter(
article=blog_temp).count()
if blog_temp.author.id != id:
isLoved = Like_Detail.objects.filter(
user=user, article=blog_temp).first()
if isLoved:
blog_data_item["isLoved"] = 1
else:
blog_data_item["isLoved"] = 0
isReferred = Recommand_Detail.objects.filter(
user=user, article=blog_temp).first()
if isReferred:
blog_data_item["isReferred"] = 1
else:
blog_data_item["isReferred"] = 0
data['blogs'] = blog_data
return restful.ok(message="操作成功", data=data)
def get_tagBlog(request):
name = request.data.get("name")
max_count = request.data.get("maxCount")
void = request.data.get("void")
if name and max_count:
try:
tag = ArticleCategory.objects.get(name=name)
except:
if void == 1:
new_tag = ArticleCategory.objects.filter(~Q(
name=name)).order_by("count").first()
if not new_tag:
return restful.fail(message="无便签可推荐")
dataa = {}
dataa["name"] = new_tag.name
dataa["count"] = Article.objects.filter(
category=new_tag).aggregate(
Count("author")).get("author__count")
articles = Article.objects.filter(category=new_tag).order_by(
"like_count", "comment_count")
count = len(articles)
if count > max_count:
count = max_count
serializer = Tag_Blog_Serializer(articles[0:count], many=True)
data_blog = serializer.data
for data_blog_item in data_blog:
data_blog_item['userId'] = data_blog_item.pop("author")
data_blog_item["pic"] = data_blog_item.pop("thumbnail")
dataa["blogs"] = data_blog
return restful.ok(message="操作成功", data=dataa)
else:
dataa = {}
dataa["name"] = []
dataa["count"] = 0
dataa["blogs"] = []
return restful.ok(message="操作成功", data=dataa)
articles = Article.objects.filter(category=tag).order_by(
"like_count", "comment_count")
count = len(articles)
if count > max_count:
count = max_count
serializer = Tag_Blog_Serializer(articles[0:count], many=True)
data = {}
if void == 1:
new_tag = ArticleCategory.objects.filter(~Q(
name=name)).order_by("count").first()
if not new_tag:
return restful.fail(message="无便签可推荐")
data["name"] = new_tag.name
tag = ArticleCategory.objects.get(name=new_tag.name)
data["count"] = Article.objects.filter(category=tag).aggregate(
Count("author")).get("author__count")
print(data["count"])
print(Article.objects.filter(category=tag).aggregate(Count("author")))
data_blog = serializer.data
for data_blog_item in data_blog:
data_blog_item['userId'] = data_blog_item.pop("author")
data_blog_item["pic"] = data_blog_item.pop("thumbnail")
data["blogs"] = data_blog
return restful.ok(message="操作成功", data=data)
else:
return restful.fail(message="传入参数错误")
def publish_Blog(request):
data = request.data
serializer = PublishSerializer(data=data)
if serializer.is_valid():
try:
user_id = serializer.data.get("id")
user = User.objects.get(pk=user_id)
except:
return restful.fail(message="用户不存在")
blog_id = serializer.data.get("blogId")
if not blog_id:
# 新建博文
title = serializer.data.get("title")
text = serializer.data.get("text")
tags = serializer.data.get("tags")
print("tags:", tags)
thumbnail = serializer.data.get("pics")
article = Article.objects.create(title=title,
text=text,
author=user,
thumbnail=thumbnail)
data = {"id": article.id}
if not tags:
return restful.ok(message="博文创建成功，没有标签分配", data=data)
tags_dict = {}
for tag in tags:
try:
blog_tag = ArticleCategory.objects.filter(name=tag).first()
article.category.add(blog_tag)
except:
# 不存在tag，则创建
print(tag, "不存在")
blog_tag = ArticleCategory.objects.create(name=tag,
count=0)
article.category.add(blog_tag)
## 修改count
article_in = Article.objects.filter(category=blog_tag).exclude(
id=article.id)
user_in = User.objects.filter(
article__in=article_in).distinct()
print("当前用户:", user)
print("已经参与用户:", user_in)
if user not in user_in:
print("in")
blog_tag.count += 1
blog_tag.save()
if blog_tag.count >= hot:
tag_item = {"name": tag, "isHot": True}
else:
tag_item = {"name": tag, "isHot": False}
tags_dict[tag] = tag_item
print(blog_tag.name, blog_tag.count)
article.save()
print(data)
data['tags'] = [tags_dict]
return restful.ok(message="博文创建成功", data=data)
else:
# 修改博文
try:
article = Article.objects.get(pk=blog_id)
except:
return restful.fail(message="博文不存在")
title = serializer.data.get("title")
text = serializer.data.get("text")
tags = serializer.data.get("tags")
print(tags)
thumbnail = serializer.data.get("pics")
data = {"id": blog_id}
article.title = title
article.text = text
if thumbnail:
article.thumbnail = thumbnail
if tags:
tags_dict = {}
for tag in tags:
try:
article_category = ArticleCategory.objects.filter(
name=tag).first()
article.category.add(article_category)
except:
article_category = ArticleCategory.objects.create(
name=tag, count=1)
article.category.add(article_category)
if article_category.count >= hot:
tag_item = {"name": tag, "isHot": True}
else:
tag_item = {"name": tag, "isHot": False}
tags_dict[tag] = tag_item
data['tags'] = [tags_dict]
article.save()
return restful.ok(message="博文修改成功", data=data)
else:
print(serializer.errors)
return restful.fail(message="参数格式错误")
def get_blogDetail(request):
id = request.data.get('id') # 博文id
user_id = request.data.get('user_id') # 当前用户id
commentSize = request.data.get('commentSize') # 评论最大数量
hotSize = request.data.get('hotSize')
if not commentSize or not hotSize:
return restful.fail(message="传入参数不足")
try:
blog = Article.objects.get(pk=id)
user = User.objects.get(pk=user_id)
except:
return restful.fail(message="用户或博文不存在")
serializer = Blog_Detail_Serializer(blog)
blog_data = {}
blog_data['blog'] = serializer.data
blog_data['blog']["time"] = blog_data['blog'].pop("pub_time")
blog_data['blog']["pics"] = []
blog_data['blog']["pics"].append(blog_data['blog'].pop("thumbnail"))
blog_data['blog']["tags"] = blog_data['blog'].pop("category")
is_loved = Like_Detail.objects.filter(user=user, article=blog).first()
if is_loved:
blog_data['blog']["isLoved"] = True
else:
blog_data['blog']["isLoved"] = False
is_Referred = Recommand_Detail.objects.filter(user=user,
article=blog).first()
if is_Referred:
blog_data['blog']["isReferred"] = True
else:
blog_data['blog']["isReferred"] = False
comment_count = Comment.objects.filter(article=blog).all().count()
blog_data['blog']['commentCount'] = comment_count
# commentList部分
blog_comment = Comment.objects.filter(article=blog).all()
# print(blog_comment.count())
if blog_comment.count() >= commentSize:
blog_comment = blog_comment[0:commentSize]
comment_serializer = CommentList_Serializer(blog_comment, many=True)
comment_data = comment_serializer.data
for comment_data_item in comment_data:
comment_data_item["text"] = comment_data_item.pop("content")
comment_data_item["user"] = comment_data_item.pop("author")
comment_data_item["user"]['name'] = comment_data_item["user"].pop(
'username')
comment_data_item["to_user"] = comment_data_item.pop("article").pop(
"author")
comment_data_item["to_user"]['name'] = comment_data_item[
"to_user"].pop('username')
blog_data["commentList"] = comment_data
# hotList 部分 未完成
like_count = Like_Detail.objects.filter(article=blog).all().count()
recommend_count = Recommand_Detail.objects.filter(
article=blog).all().count()
blog_data['blog']['hotCount'] = like_count + recommend_count # 未完成，待修改
# user_like = User.objects.filter(like_detail__article=blog).all()
# user_recommend = User.objects.filter(recommand_detail__article=blog).all()
# print(user_like)
# print(user_recommend)
cursor = connection.cursor()
cursor.execute(
"select * from(select date_recommand time,article_id,user_id,1 as type from user_recommand_detail union select date_like time,article_id,user_id,0 as type from user_like_detail) tab order by time desc"
)
rows = cursor.fetchall()
hot_dict = []
for row in rows:
if row[1] != id:
continue
hot_user = User.objects.get(pk=row[2])
serializer_hot = HotList_Serializer(hot_user)
hot_data = serializer_hot.data
hot_data['type'] = row[3]
hot_data['name'] = hot_data.pop('username')
hot_dict.append(hot_data)
print(row)
if len(hot_dict) >= hotSize:
hot_dict = hot_dict[0:hotSize]
blog_data['hotList'] = hot_dict
return restful.ok(message="操作成功", data=blog_data)
