def post(self, request, format=None):
user = request.user
serializer = PostSerializer(data=request.data, context={'user': user})
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, format=None):
user = request.user
serializer = PostSerializer(data=request.data, context={'user':user})
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def put(self, request, pk, format=None):
response = {}
response["status"] = message.SUCCESS
try:
post = self.get_object(pk)
request.data["user"] = request.user.id
serializer = PostSerializer(post, data=request.data)
if serializer.is_valid():
serializer.save()
response["data"] = serializer.data
response["message"] = message.UPDATE_POST_SUCCESS
#update_post_attributes(request.data["attributes"],serializer.data["id"])
else:
response["message"] = serializer.errors
except Exception as exp:
print(exp)
traceback.print_exc()
response["status"] = message.ERROR
response["message"] = str(exp)
if response["status"] == message.SUCCESS:
return JSONResponse(response, status=status.HTTP_200_OK)
else:
return JSONResponse(response, status=status.HTTP_400_BAD_REQUEST)
def find_post_by_id(request, post_id):
post = Post.objects.filter(id=post_id).first()
if post:
if post.community.state is True:
if not request.user.is_authenticated:
serializer = PostSerializer(post, context={"request": request})
return Response(serializer.data, status=200)
if post.user == request.user:
track = Track.objects.filter(user=request.user).first()
check_community_track(track, post.community, request.user)
serializer = PostSerializer(post, context={"request": request})
return Response(serializer.data, status=200)
track = Track.objects.filter(user=request.user).first()
check_community_track(track, post.community, request.user)
view = View.objects.filter(user=request.user, post=post).first()
serializer = check_view(view, post, request.user, request)
return Response(serializer.data, status=200)
if post.community.state is False:
if not request.user.is_authenticated:
return Response({Message.SC_LOGIN_REDIRECT}, status=401)
view = View.objects.filter(user=request.user, post=post).first()
if Community.objects.filter(user=request.user,
community_type=post.community):
serializer = check_view(view, post, request.user, request)
return Response(serializer.data, status=200)
return Response({Message.MUST_FOLLOW}, status=400)
return Response({Message.SC_NOT_FOUND}, status=204)
def post(self, request, format=None):
print('You hit add post')
response = {}
response["status"] = message.SUCCESS
try:
data = request.data
data["user"] = request.user.id
print(data)
serializer = PostSerializer(data=data)
if serializer.is_valid():
serializer.save()
response["data"] = serializer.data
response["message"] = message.CREATE_POST_SUCCESS
else:
response["message"] = serializer.errors
except Exception as exp:
print(exp)
traceback.print_exc()
response["status"] = message.ERROR
response["message"] = str(exp)
if response["status"] == message.SUCCESS:
return JSONResponse(response, status=status.HTTP_201_CREATED)
else:
return JSONResponse(response, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, pk):
post = get_object_or_404(Post, pk=pk)
serializer = PostSerializer(post, data=request.data)
if not serializer.is_valid():
return Response({'serializer': serializer, 'post': post})
serializer.save()
return redirect('store-detail',post.poster.id)
def post_message(request):
if request.method == "POST":
serializer = PostSerializer(data=request.data)
if serializer.is_valid():
print(serializer.data)
message = serializer.validated_data.get("message")
message_type = serializer.validated_data.get("message_type")
Post.objects.create(message=message, message_type=message_type)
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def put(self, request, pk1, pk2):
try:
instance = self.get_profile(pk1=pk1).posts.get(id=pk2)
except Post.DoesNotExist:
raise Http404
serializer = PostSerializer(instance=instance, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors)
def post(self, request):
serializer = PostSerializer(data=request.data)
if not serializer.is_valid():
return Response({'serializer': serializer})
user=self.request.user
# post와 유저를 연결, post에관한 유저정보는 사용자가 입력하는 것이아닌 자동으로
serializer.save(poster=user,restaurant=user.store.store_name,local=user.store.store_local)
# perform_create()가 serializer.save()를 해줌
return redirect('post-list')
def put(self, request, pk, format=None):
try:
post = Post.objects.get(id=pk)
except:
return Response(status=status.HTTP_404_NOT_FOUND)
serializer = PostSerializer(post, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def create_post(request):
if not request.user.is_authenticated:
return Response({Message.SC_LOGIN_REDIRECT}, status=401)
if request.method == "POST":
title = request.data.get("title")
content = request.data.get("content")
community = request.data.get("community")
image = request.data.get('image')
type = request.data.get('type')
if community is None:
return Response({Message.SC_BAD_RQ}, status=400)
user = request.user
if community:
if Community.objects.filter(community_type=community):
_community = Community.objects.filter(
community_type=community).first()
positive_point = PositivePoint.objects.filter(
user=user).first()
positive_point.point = positive_point.point + 1
positive_point.save()
if image:
if len(image) > len('data:,'):
current_post = Post.objects.create(
user=user,
content=content,
community=_community,
title=title,
type=PostType.objects.filter(type=type).first())
current_post.image = get_image(image)
current_post.point = rank.hot(0, 0,
current_post.timestamp)
current_post.save()
serializer = PostSerializer(
current_post, context={"request": request})
return Response(serializer.data, status=201)
current_post = Post.objects.create(
user=user,
content=content,
community=_community,
title=title,
type=PostType.objects.filter(type=type).first())
current_post.point = rank.hot(0, 0, current_post.timestamp)
current_post.save()
serializer = PostSerializer(current_post,
context={"request": request})
return Response(serializer.data, status=201)
return Response({Message.SC_BAD_RQ}, status=400)
return Response({Message.SC_BAD_RQ}, status=400)
def get(self, request):
tag_name = request.GET.get('keyword', '')
posts = Post.objects.filter(
tags__name__exact=tag_name).order_by('-created_at')
serialized_posts = PostSerializer(posts, many=True)
return Response(serialized_posts.data)
def get(self, request):
title = request.GET.get('keyword', '')
posts = Post.objects.filter(
title__contains=title).order_by('-created_at')
serialized_posts = PostSerializer(posts, many=True)
return Response(serialized_posts.data)
def get(self, request):
posts = Post.objects.filter(
author__user_id=request.user.id).order_by('id')
paginator = PageNumberPagination()
result_page = paginator.paginate_queryset(posts, request)
ser = PostSerializer(result_page, many=True)
return Response(ser.data)
def post_status(request, pk):
response = {}
response["status"] = message.SUCCESS
try:
post = Post.objects.get(pk=pk)
if request.method == "GET":
output = {}
output["status"] = post.status
output["is_verified"] = post.is_verified
response["data"] = output
elif request.method == "PUT":
data = request.data
post["is_verified"] = data["is_verified"]
post["status"] = data["status"]
post.save()
serializer = PostSerializer(post)
response["data"] = serializer.data
except Exception as exp:
print(exp)
traceback.print_exc()
response["status"] = message.ERROR
response["message"] = str(exp)
if response["status"] == message.SUCCESS:
return JSONResponse(response, status=status.HTTP_200_OK)
else:
return JSONResponse(response, status=status.HTTP_400_BAD_REQUEST)
def delete(self, request, pk):
post = Post.objects.get(pk=pk)
serializer_class = PostSerializer(post)
#password = request.data.get('password', None)
#if password == post.password:
post.delete()
return Response({"message":"success"})
def get(self, request, pk1, pk2):
try:
post = self.get_profile(pk1=pk1).posts.get(id=pk2)
except Post.DoesNotExist:
raise Http404
serializer = PostSerializer(post)
return Response(serializer.data, status=status.HTTP_200_OK)
def userProfileView(request, un):
tasks = User_Profile.objects.filter(username=un)
serializer = user_profile_serializer(tasks, many=True)
#problem
pos = Post.objects.filter(username=un)
serializer2 = PostSerializer(pos, many=True)
#solution
sol = Solution.objects.filter(username=un)
serializer3 = SolutionSerializer(sol, many=True)
#user_personal
personal = User_Personal.objects.filter(username=un)
serializer4 = user_personal_serializer(personal, many=True)
#user_professional
professional = User_Professional.objects.filter(username=un)
serializer5 = user_professional_serializer(professional, many=True)
#email
em = CustomUser.objects.filter(id=un)
serializer6 = LoginSerializer(em, many=True)
content = {"email": serializer6.data[0].get('email')}
Serializer_list = [
serializer.data, serializer2.data, serializer3.data, serializer4.data,
serializer5.data, content
]
return Response(Serializer_list, safe=False) # returns list of json
def to_representation(self, value):
if isinstance(value, User):
return UserSerializer(value).data
elif isinstance(value, Post):
return PostSerializer(value, context={'request': None}).data
else:
return 'unknown'
class DiarySerializer(serializers.ModelSerializer):
post_list = PostSerializer(many=True, read_only=True)
goal_list = GoalSerializer(many=True, read_only=True)
class Meta:
model = Diary
fields = ('id', 'created_at' , 'updated_at', 'user', 'account_num', 'bank', 'money',
'image', 'title', 'post_list', 'goal_list')
def test_list_post(self):
"""
Test listing posts
"""
res = self.client.get(POST_URL)
posts = Post.objects.all()
serializer = PostSerializer(many=True)
self.assertEqual(res.data, serializer.data)
def get(self, request, pk, format=None):
try:
post = Post.objects.get(id=pk)
except:
return Response(status=status.HTTP_404_NOT_FOUND)
serializer = PostSerializer(post)
return Response(serializer.data, status=status.HTTP_200_OK)
def top_posts(request):
post = [p for p in Post.objects.all()]
post = sorted(post, key=lambda x: x.vote_total(), reverse=True)
serializer = PostSerializer(post, many=True)
return Response(data=serializer.data, status=status.HTTP_200_OK)
def detail(request, pk):
"""
Retrieve, update or delete a code post.
"""
try:
post = Post.objects.get(pk=pk)
except Post.DoesNotExist:
response = {"message": "post not exists"}
return Response(response, status=status.HTTP_404_NOT_FOUND)
if request.method == 'GET':
serializer = PostSerializer(post)
return Response(serializer.data)
elif request.method == 'PUT':
request = uploadFile(request)
serializer = PostSerializer(post, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
elif request.method == 'DELETE':
post.delete()
respone = {"message": "bạn đã xóa thành công bài post id = " + str(pk)}
return Response(respone, status=status.HTTP_204_NO_CONTENT)
def get(self, request, user_id):
user = get_object_or_404(UserProfile, id=user_id)
forum = PostSerializer(user.bookmarked_posts.all(),
many=True,
context={
'request': request,
'user': user.user
})
return Response(forum.data, status=status.HTTP_200_OK)
def re_post(request, post_id):
if not request.user.is_authenticated:
return Response({Message.SC_LOGIN_REDIRECT}, status=401)
post = Post.objects.filter(id=post_id).first()
if post:
new_post = Post.objects.create(parent=post, user=request.user)
serializer = PostSerializer(new_post, context={"request": request})
return Response(serializer.data, status=200)
return Response({Message.SC_NOT_FOUND}, status=204)
def to_representation(self, value):
if isinstance(value, Post):
serializer = PostSerializer(value)
else:
return value.__str__()
return serializer.data
def get(self, request):
user = request.user.profile
user_following = Follow.objects.filter(follower=user).all()
# user_posts = Post.objects.filter(written_by = user).all()
response = list()
for person in user_following:
for vote in person.user.votes.filter(vote_type='like').all():
if vote.post in response:
continue
serializer = PostSerializer(vote.post,
context={
'request': request,
'user': user.user
})
data = serializer.data.copy()
data[
'message'] = f'{person.user.first_name} {person.user.last_name} liked this post'
response.append(data)
for comment in person.user.comments_made.all():
if comment.post in response:
continue
serializer = PostSerializer(comment.post,
context={
'request': request,
'user': user.user
})
data = serializer.data.copy()
data[
'message'] = f'{person.user.first_name} {person.user.last_name} commented on this post'
response.append(data)
for user_followed in user_following:
posts = Post.objects.filter(written_by=user_followed.user).all()
for post in posts:
if post in response:
continue
serializer = PostSerializer(post,
context={
'request': request,
'user': user.user
})
data = serializer.data.copy()
data['message'] = None
response.append(data)
return Response(response, status=status.HTTP_200_OK)
def get(self, request, profile_id):
user = get_object_or_404(UserProfile, id=profile_id)
query = Post.objects.filter(written_by=user)
serializer = PostSerializer(query,
many=True,
context={
'request': request,
'user': request.user
})
return Response(serializer.data, status=status.HTTP_200_OK)
def test_filter_post_by_title(self):
"""Test returning post searched post."""
post1 = sample_post(user_id=self.user, title="Hello programmer")
post2 = sample_post(user_id=self.user, title="We love programmer")
post3 = sample_post(user_id=self.user, title="The code defines you")
tag1 = sample_tag(user=self.user, name="Finance")
tag2 = sample_tag(user=self.user, name="Technology")
post1.tags.add(tag1)
post2.tags.add(tag2)
post3.tags.add(tag1)
res = self.client.get(POST_URL, {'search': f'programmer'})
serializer1 = PostSerializer(post1)
serializer2 = PostSerializer(post2)
serializer3 = PostSerializer(post3)
self.assertIn(serializer1.data, res.data)
self.assertIn(serializer2.data, res.data)
self.assertNotIn(serializer3.data, res.data)
def test_retrieve_post(self):
"""Test retrieving list of posts"""
# sample_post(user_id=self.user)
# sample_post(user_id=self.user)
res = self.client.get(POST_URL)
posts = Post.objects.all().order_by('-id')
serializer = PostSerializer(posts, many=True)
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertEqual(res.data, serializer.data)
