def posts_details(request, pk): # Here pk corresponds to the id
try:
post = Post.objects.get(pk=pk) # get the post with the matching id
except Post.DoesNotExist:
# if it does not exist, return the error message with 404
return JsonResponse({'message': 'There is no post with such id'}, status=status.HTTP_404_NOT_FOUND)
# return the post with the id if the method is get
if request.method == 'GET':
post_serializer = PostSerializer(post)
return JsonResponse(post_serializer.data, status=status.HTTP_200_OK)
# delete it if the method is DELETE
elif request.method == 'DELETE':
post.delete()
return JsonResponse({'message': 'post deleted successfully !'}, status=status.HTTP_204_NO_CONTENT)
elif request.method == 'PUT':
# we parse the data ( passed as a parameter ) and the we serialize it to the post with the matching id
post_data = JSONParser().parse(request)
post_serializer = PostSerializer(post, data=post_data)
# if the serialization is valid, save it
if post_serializer.is_valid():
post_serializer.save()
return JsonResponse(post_serializer.data)
# else return a bad request status code
return JsonResponse(post_serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post_detail(request, post_id):
try:
post = Post.objects.get(pk=post_id)
except Post.DoesNotExist:
return Response({"message": "requested post not found"},
status=status.HTTP_404_NOT_FOUND)
if request.method == 'GET':
serializer = PostSerializer(post)
return Response({"data": serializer.data})
if request.method == 'DELETE':
post.delete()
return Response({"message": "Post has been deleted !"},
status=status.HTTP_204_NO_CONTENT)
if request.method == 'PUT':
serializer = PostSerializer(post, data=request.data)
if serializer.is_valid():
serializer.save()
return Response({
"message": "update post successfully",
"data": serializer.data
})
return Response({"message": "update post failed"},
status=status.HTTP_400_BAD_REQUEST)
def get(self, request, format=None):
if request.GET.get('startID') is None:
# Get all answers for a question
questionID = int(request.GET.get('questionID'))
question = Question.objects.get(pk=questionID)
post = question.post
answers = PostSerializer(post.child_posts.all(), many=True)
return Response(answers.data)
else:
# Get 'count' answers of question from startID
questionID = int(request.GET.get('questionID'))
startID = int(request.GET.get('startID'))
count = int(request.GET.get('count'))
try:
question = Question.objects.get(pk=questionID)
except:
return Response({'message': 'Question not exists'},
status=status.HTTP_400_BAD_REQUEST)
answers = question.post.child_posts.all().order_by('-id')
result = []
for answer in answers:
if count <= 0:
break
if (startID != 0 and answer.id < startID) or (startID == 0):
result.append(answer)
count -= 1
serializer = PostSerializer(result, many=True)
return Response(serializer.data, status=status.HTTP_200_OK)
def browse(request, n):
topics = ['politics', 'health', 'sport', 'tech']
status = ['live', 'expired']
interrest = ['highestinterest', 'lowestinterest']
query_action = n.split('+')
# list of actions:
my_filter = {}
interest = 0
for i in query_action:
# Ignore spoace Cap Letter and "-" "_"
action = i.lower()
action = action.replace(" ", "")
action = action.replace("_", "")
action = action.replace("-", "")
if action in topics:
#find the topic to select
my_action = 'topic__icontains'
my_filter[my_action] = action.capitalize()
elif action in status:
my_action = 'status__icontains'
my_filter[my_action] = action.capitalize()
elif action in interrest:
if action == 'highestinterest':
interest = 1
else:
interest = 2
queryset = Post.objects.all().filter(**my_filter)
if interest == 1:
queryset = queryset.annotate(
total_like=Sum(F('likes') + F('dislikes'))).order_by('total_like')
queryset = queryset.last()
queryset = Post.objects.filter(pk=queryset.pk)
elif interest == 2:
queryset = queryset.annotate(
total_like=Sum(F('likes') + F('dislikes'))).order_by('total_like')
queryset = queryset.first()
queryset = Post.objects.filter(pk=queryset.pk)
if not (len(my_filter) == 0 and interest == 0):
for item in queryset:
# update all the time to exipire
t = item.time_to_expire() # get time to expire
t = timezone.timedelta(seconds=int(t))
serializer = PostSerializer(item)
queryset_comment = Comment.objects.filter(
post=serializer.data['id']
) # find all the comment related to a post
queryset_preference = Preference.objects.filter(
post=serializer.data['id']
) # find all the preference related to a post
update_time(queryset_comment, t, CommentSerializer)
update_time(queryset_preference, t, PreferenceSerializer)
serializer = PostSerializer(queryset, many=True)
return Response(serializer.data)
else:
return Response('No Action in ' + n + ' is recognised')
def posts_list(request):
if request.method == 'GET':
# get all posts
posts = Post.objects.all()
title = request.GET.get('title', None) # ( the title is passed as a parameter )
# if title is in the parameters, then filter the posts with the title
if title is not None:
posts = posts.filter(title__icontains=title)
# we serialize the posts and return a JsonResponse with the serialized data
posts_serializer = PostSerializer(posts, many=True)
return JsonResponse(posts_serializer.data, safe=False)
elif request.method == 'POST':
# we parse thr request to get the post data and then we serialize it
post_data = JSONParser().parse(request)
post_serializer = PostSerializer(data=post_data)
# if the serializer is valid we save the serialized data (our post) and we return it with a status of 201
if post_serializer.is_valid():
post_serializer.save()
return JsonResponse(post_serializer.data, status=status.HTTP_201_CREATED)
# else we return the error raised from the serialization with a satus of 400
return JsonResponse(post_serializer.errors, status=status.HTTP_400_BAD_REQUEST)
elif request.method == 'DELETE':
count = Post.objects.all().delete()
return JsonResponse({'message': f"{count} posts were deleted successfully !"}, status=status.HTTP_204_NO_CONTENT)
def test_post_detail(self, client, post_factory):
test_url = reverse_lazy(self.post_detail_url, args=(1,))
for http_method in ('post', 'put', 'patch', 'delete'):
response = getattr(client, http_method)(test_url)
assert response.status_code == status.HTTP_405_METHOD_NOT_ALLOWED
url = reverse_lazy(self.post_detail_url, args=(100500,))
response = client.get(url)
assert response.status_code == status.HTTP_404_NOT_FOUND
draft_post = post_factory(status=Post.DRAFT)
url = reverse_lazy(self.post_detail_url, args=(draft_post.id,))
response = client.get(url)
assert response.status_code == status.HTTP_404_NOT_FOUND
non_draft_post = post_factory(status=Post.PUBLISHED)
url = reverse_lazy(self.post_detail_url, args=(non_draft_post.id,))
response = client.get(url)
assert response.status_code == status.HTTP_200_OK
assert response.data == PostSerializer(non_draft_post).data
client.force_authenticate(draft_post.author)
url = reverse_lazy(self.post_detail_url, args=(draft_post.id,))
response = client.get(url)
assert response.status_code == status.HTTP_200_OK
assert response.data == PostSerializer(draft_post).data
def test_post_create(self, client, faker):
for http_method in ('get', 'post', 'put', 'patch', 'delete'):
response = getattr(client, http_method)(self.post_create_url)
assert response.status_code == status.HTTP_401_UNAUTHORIZED
user = User.objects.annotate(
posts_total=Count('posts')
).last()
client.force_authenticate(user)
for http_method in ('get', 'put', 'patch', 'delete'):
response = getattr(client, http_method)(self.post_create_url)
assert response.status_code == status.HTTP_405_METHOD_NOT_ALLOWED
payloads = {}
response = client.post(self.post_create_url, data=payloads)
assert response.status_code == status.HTTP_400_BAD_REQUEST
assert len(response.data['codes']) == 2
assert self.title_field in response.data
assert self.body_field in response.data
assert response.data.get(self.title_field) == ['This field is required.']
assert response.data.get(self.body_field) == ['This field is required.']
payloads.update({
self.title_field: faker.sentence(),
self.body_field: faker.text(),
self.allow_comments_field: True,
})
user_posts_count = user.posts_total
response = client.post(self.post_create_url, data=payloads)
assert response.status_code == status.HTTP_201_CREATED
assert response.data == PostSerializer(Post.objects.get(id=response.data.get('id'))).data
assert response.data.get(self.status_field) == Post.PUBLISHED
assert response.data.get(self.allow_comments_field)
user.refresh_from_db()
user.posts_total = user_posts_count + 1
payloads.update({
self.title_field: faker.sentence(),
self.body_field: faker.text(),
self.allow_comments_field: True,
self.status_field: Post.DRAFT,
})
user_posts_count = user.posts_total
response = client.post(self.post_create_url, data=payloads)
assert response.status_code == status.HTTP_201_CREATED
assert response.data == PostSerializer(Post.objects.get(id=response.data.get('id'))).data
assert response.data.get(self.status_field) == Post.DRAFT
assert response.data.get(self.allow_comments_field)
user.refresh_from_db()
user.posts_total = user_posts_count + 1
def test_create_post_with_unique_slug(self):
"""Test creating post with unique slug"""
post1 = sample_post(user=self.user, title='Post 01')
post2 = sample_post(user=self.user, title='Post 02')
serializer1 = PostSerializer(post1)
serializer2 = PostSerializer(post2)
self.assertNotEqual(serializer1.data['slug'], serializer2.data['slug'])
def get(self, request, format=None):
team_id = request.GET.get('team')
if team_id:
posts = Post.objects.filter(team=team_id)
serializer = PostSerializer(posts, many=True)
return Response(serializer.data)
posts = Post.objects.filter(user=request.user)
serializer = PostSerializer(posts, many=True)
return Response(serializer.data)
def posts(request):
if request.method == "GET":
posts = Post.objects.order_by('-pub_date')
serializer = PostSerializer(posts, many=True)
return Response(serializer.data)
elif request.method == "POST":
serializer = PostSerializer(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 test_clear_inbox(self):
"""Test clearing items in Inbox"""
inbox = self.create_inbox()
post_1 = PostSerializer(self.post_1).data
post_2 = PostSerializer(self.post_1).data
inbox.items.append(post_1)
inbox.items.append(post_2)
self.assertEqual(len(inbox.items), 2)
inbox.items.clear()
self.assertEqual(len(inbox.items), 0)
def post_list(request):
if request.method == 'GET':
posts = Post.objects.all()
content = request.GET.get('content', None)
if content is not None:
posts = posts.filter(content__icontains=content)
posts_serializer = PostSerializer(posts, many=True)
return JsonResponse(posts_serializer.data, safe=False)
elif request.method == 'POST':
comment_list = []
post_data = JSONParser().parse(request)
post_serializer = PostSerializer(data=post_data, many=True)
if post_serializer.is_valid():
# print(post_serializer.data)
for i in post_serializer.data:
str = []
# print(i.get('content'))
str.append('*' + i.get('content') + '*')
# comment_list.append('*' + i.get('content') + '*')
trustNumber, resultBoolean = model_predict_comment(
model_dict['SARNNKerasCPU'], model_path, str)
print(trustNumber)
print(resultBoolean)
i.update(resultInNumber=trustNumber)
i.update(resultInBoolean=resultBoolean)
# model_predict_comment(model_dict['SARNNKerasCPU'],model_path,comment_list)
# post_serializer.save()
return JsonResponse(post_serializer.data,
status=status.HTTP_201_CREATED,
safe=False)
return JsonResponse(post_serializer.data,
status=status.HTTP_400_BAD_REQUEST)
elif request.method == 'PUT':
post_data = JSONParser().parse(request)
post_serializer = PostSerializer(data=post_data, many=True)
print(post_serializer)
if post_serializer.is_valid():
post_serializer.save()
return JsonResponse(post_serializer.data, safe=False)
return JsonResponse(post_serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
elif request.method == 'DELETE':
count = Post.objects.all().delete()
return JsonResponse(
{'message': '{} posts were deleted successfully'.format(count[0])},
status=status.HTTP_204_NO_CONTENT)
def post_list(request):
if request.method == 'GET':
queryset = Post.objects.all()
serializer = PostSerializer(queryset, many=True)
return JsonResponse(serializer.data, safe=False)
if request.method == 'POST':
data = JSONParser.parse(request)
serializer = PostSerializer(data=data)
if serializer.is_valid():
serializer.save()
return JsonResponse(serializer.data, status=201)
return JsonResponse(serializer.errors, status=400)
def test_edit_post_after_sending(self):
"""Test editing Post after sending to Inbox"""
inbox = self.create_inbox()
post_1 = PostSerializer(self.post_1).data
inbox.items.append(post_1)
self.assertEqual(post_1, inbox.items[0])
self.post_1.title = "Modified Title"
modified_post_1 = PostSerializer(self.post_1).data
self.assertEqual(post_1, inbox.items[0])
self.assertNotEqual(modified_post_1, inbox.items[0])
self.assertNotEqual(modified_post_1, post_1)
def post(self, request):
post = request.data
serializer = PostSerializer(data=post,
context={'request': request})
if serializer.is_valid(raise_exception=True):
serializer.save()
return Response({"success": f"Post created successfully"})
def get(self, request, format=None, **kwargs):
search_term = request.GET.get('q', '')
serializer_context = {'request': request}
posts = PostSerializer(
Post.objects.filter(title__icontains=search_term),
many=True,
context=serializer_context)
users = UserSerializer(
User.objects.filter(username__icontains=search_term),
many=True,
context=serializer_context)
subreddits = SubSerializer(
Sub.objects.filter(title__icontains=search_term),
many=True,
context=serializer_context)
data = {
'posts': posts.data,
'users': users.data,
'subreddits': subreddits.data,
}
return Response(data=data)
def home(request):
if request.user.is_authenticated:
user_profile = get_object_or_404(Profile, user=request.user)
following_list = []
for following in user_profile.following:
following_list.append(following["username"])
post_list = []
for user in following_list:
u = get_object_or_404(User, username=user)
posts = Post.objects.filter(user=u)
for post in posts:
profile = get_object_or_404(Profile, user=post.user)
user_profile = ProfileSerializer(profile, many=False)
is_current_user_liked = False
if any(x["id"] == request.user.id for x in post.likes):
is_current_user_liked = True
post = PostSerializer(post, many=False)
post_list.append({
"post": post.data,
"is_current_user_liked": is_current_user_liked,
"profile": user_profile.data
})
post_list = sorted(post_list,
key=lambda x: x["post"]["timestamp"],
reverse=True)
return Response(post_list, status=status.HTTP_200_OK)
else:
return Response({"error": "Authentication credential not provided"},
status=status.HTTP_401_UNAUTHORIZED)
def put(self, request, pk, *args, **kwargs):
post = Post.objects.get(pk=pk)
serializer = PostSerializer(post, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status=HTTP_400_BAD_REQUEST)
def search(request):
if request.data.get("keyword"):
post_list = []
user_list = []
posts = Post.objects.filter(
caption__contains=request.data.get("keyword"))
for post in posts:
post = PostSerializer(post, many=False)
post_list.append(post.data)
post_list = sorted(post_list,
key=lambda x: x["timestamp"],
reverse=True)
users = User.objects.filter(
username__contains=request.data.get("keyword"))
for user in users:
user = UserSerializer(user, many=False)
user_list.append(user.data)
# user_list = sorted(
# user_list, key=lambda x: x["last_login"], reverse=True)
return Response(
{
"posts": {
"post_result": post_list,
"result_length": len(post_list)
},
"users": {
"user_result": user_list,
"result_length": len(user_list)
},
},
status=status.HTTP_200_OK)
else:
return Response({"keyword": "This field is required."},
status=status.HTTP_400_BAD_REQUEST)
def post(self, request, pk, format=None):
event = self.get_object(pk)
postform = PostForm(request.data)
if postform.is_valid():
post = postform.save(commit=False)
post.author = request.user
post.object_id = event.id
post.object_name = event.name
post.object_type = 'Event'
post.object_is_private = event.is_private
post.save()
try:
image_ids = request.data['images']
images = PostFiles.objects.filter(id__in=image_ids)
for image in images:
post.images.add(image)
except:
pass
event.posts.add(post)
searchindex = IndexObject('post', post.id)
serializer = PostSerializer(post, context={'request': request})
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, *args, **kwargs):
serializer = PostSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=HTTP_201_CREATED)
else:
return Response(serializer.errors, status=HTTP_400_BAD_REQUEST)
class CommentSerializer(serializers.ModelSerializer):
created_by = UserSerializer(required=False)
created_by_id = serializers.IntegerField(write_only=True,
required=False,
allow_null=True)
post = PostSerializer(required=False, read_only=True)
post_id = serializers.IntegerField(write_only=True,
required=False,
allow_null=True)
class Meta:
model = Comments
fields = (
'id',
'text',
'created_by',
'created_by_id',
'post',
'post_id',
)
def create(self, validated_data):
comments = Comments.objects.create(**validated_data)
post_id = validated_data.get("post_id")
validated_data.pop("post_id", None)
post = Posts.objects.filter(id=post_id).first()
comments.post = post
comments.save()
return comments
def get(self, request, pk, format=None):
event = self.get_object(pk)
posts = event.posts.all().order_by('-id')
serializer = PostSerializer(posts,
many=True,
context={'request': request})
return Response(serializer.data)
def posts_list(request):
"""
List posts.
"""
if request.method == 'GET':
data = []
nextPage = 1
previousPage = 1
customers = Post.objects.all()
page = request.GET.get('page', 1)
paginator = Paginator(customers, 10)
try:
data = paginator.page(page)
except PageNotAnInteger:
data = paginator.page(1)
except EmptyPage:
data = paginator.page(paginator.num_pages)
serializer = PostSerializer(data,
context={'request': request},
many=True)
if data.has_next():
nextPage = data.next_page_number()
if data.has_previous():
previousPage = data.previous_page_number()
url = reverse('list_posts_api_v1')
return Response({
'data': serializer.data,
'count': paginator.count,
'numpages': paginator.num_pages,
'nextlink': url + '?page=' + str(nextPage),
'prevlink': url + '?page=' + str(previousPage)
})
def latest(self, request):
posts = paginate_queryset(
Post.get_user_view(request.user.id).filter(parent=None), request,
'id', self.page_size)
serializer = PostSerializer(posts, many=True)
return Response(serializer.data)
def post(self, request, format=None):
serializer = PostSerializer(data=request.data)
if serializer.is_valid():
post = serializer.save(user=request.user)
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
class ProfileSerializer(serializers.ModelSerializer):
posts = serializers.PrimaryKeyRelatedField(many=True, read_only=True)
post = PostSerializer(write_only=True)
user_id = serializers.IntegerField(write_only=True)
user = serializers.CharField(read_only=True)
class Meta:
model = Profiles
fields = '__all__'
def validate_phone_number(self, value):
phone_number_pattern = re.compile("^09\d{9}$")
if phone_number_pattern.match(value):
return value
else:
raise ValidationError("phone number is not correct.")
def create(self, validated_data):
if 'post' in validated_data:
users = validated_data.pop('user_id')
profile_user = get_object_or_404(User, pk=users)
post = validated_data.pop('post')
profile = Profiles.objects.create(user=profile_user,
**validated_data)
my_post = Posts.objects.create(**post, author=profile)
return profile
else:
users = validated_data.pop('user_id')
profile_user = get_object_or_404(User, pk=users)
profile = Profiles.objects.create(user=profile_user,
**validated_data)
return profile
class CommentSerializer(serializers.ModelSerializer):
author = UserSerializer(read_only=True)
post_comment = PostSerializer(read_only=True)
class Meta:
model = Comment
fields = ['id', 'text_content', 'author', 'post_comment']
def get(self, request, format=None):
"""
Return a list of all posts.
"""
posts = Post.objects.all()
serializer = PostSerializer(posts, many=True)
return Response(serializer.data)
def get(self, request, pk, format=None):
"""
Retrieve a post instance
"""
post = self.get_object(pk)
serializer = PostSerializer(post)
return Response(serializer.data)
