def new_post(request):
# data is passed as a string and needs to be converted to a dict
data = json.loads(request.data['data'])
client = get_object_or_404(Client, user=request.user)
if request.data.get('file'):
data['image'] = request.data['file']
if 'blog' in data:
blog = get_object_or_404(Blog, id=data['blog'])
else:
topic = Topic.objects.get(name="Personal")
blog = Blog.objects.get(topic=topic, owner__in=[client])
data.update({'blog': blog.id})
# check permissions to create new post on this blog
if not blog.isPublic and client not in blog.subs.all():
data = {'error': 'not enough permissions'}
else:
data.update({'client': client.id})
post_serializer = PostSerializer(data=data)
if post_serializer.is_valid():
post_serializer.save()
data = {
'success': 'successfully created a new post',
'post': post_serializer.data
}
else:
data = post_serializer.errors
return Response(data)
def update(self, request, *args, **kwargs):
pk = kwargs['pk']
snippet = self.get_object(pk)
if snippet.author != request.user.id:
return Response({"error": "only author can update post"},
status=status.HTTP_400_BAD_REQUEST)
data = request.data.dict()
if not data.get('title'):
data['title'] = snippet.title
if not data.get('text'):
data['text'] = snippet.title
data['author'] = snippet.author.id
data['liked'] = snippet.liked
data['liked'] = snippet.unliked
data['liked'] = snippet.total_liked
serializer = PostSerializer(snippet, data=data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, format=None):
print 'In post hander'
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.error, status=status.HTTP_400_BAD_REQUEST)
def test_post_serializer_is_invalid(self):
post_obj_data = {
u'title': u'title',
u'code': u'code',
u'ttl_option': u'minutes=10',
u'syntax': "1"
}
post_serializer = PostSerializer(data=post_obj_data)
self.assertFalse(post_serializer.is_valid())
def test_post_serializer_is_invalid(self):
post_obj_data = {
u'title': u'title',
u'code': u'code',
u'ttl_option': u'minutes=10',
u'syntax': "1"
}
post_serializer = PostSerializer(data=post_obj_data)
self.assertFalse(post_serializer.is_valid())
def patch(self, request, pk):
post = get_object_or_404(Post, pk=pk)
data = {"amount_of_upvotes": post.amount_of_upvotes + 1}
serializer = PostSerializer(post, data=data, partial=True)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def test_post_serializer_is_valid(self):
Syntax.objects.create(syntax_name="syntax_name1")
post_obj_data = {
u'title': u'title',
u'code': u'code',
u'ttl_option': u'minutes=10',
u'syntax': "1"
}
post_serializer = PostSerializer(data=post_obj_data)
self.assertTrue(post_serializer.is_valid())
def test_post_serializer_is_valid(self):
Syntax.objects.create(syntax_name="syntax_name1")
post_obj_data = {
u'title': u'title',
u'code': u'code',
u'ttl_option': u'minutes=10',
u'syntax': "1"
}
post_serializer = PostSerializer(data=post_obj_data)
self.assertTrue(post_serializer.is_valid())
def put(self, request, pk, format=None):
post = self.get_object(pk)
self.check_object_permissions(self.request, post)
if post.category != request.data.get('category'):
return Response(status=status.HTTP_400_BAD_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)
def post(self):
form = PostCreateForm()
if not form.validate_on_submit():
return form.errors, 422
post = Post(form.title.data, form.body.data)
db.session.add(post)
db.session.commit()
return PostSerializer(post).data, 201
def test_post_list(self):
"""Test retrieving a list of posts"""
create_runnings()
res = self.client.get(POSTS_URL)
posts = Post.objects.order_by('-date')[:10]
serializer = PostSerializer(posts, many=True)
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertEqual(res.data['results'], serializer.data)
def user_posts_detail(request, pk, pk_post):
"""
List all code snippets, or create a new snippet.
"""
if request.method == 'GET':
print(pk)
print(pk_post)
snippets = Post.objects.get(id=pk_post, profile=pk)
serializer = PostSerializer(snippets, many=False)
return JsonResponse(serializer.data, safe=False)
elif request.method == 'PUT':
data = JSONParser().parse(request)
original = Post.objects.get(id=pk_post, profile=pk)
serializer = PostSerializer(original, data=data)
if serializer.is_valid():
serializer.save()
return JsonResponse(serializer.data, status=201)
return JsonResponse(serializer.errors, status=400)
elif request.method == 'DELETE':
Post.objects.get(id=pk_post, profile=pk).delete()
return JsonResponse({"Deleted": "True"}, status=201, safe=False)
return JsonResponse({"Method Not Allowed": "True"}, status=405)
def PostList(request):
if request.method == 'GET':
#posts = Post.objects.select_related().annotate(username=F('user__username')).annotate(password=F('user__password')).order_by('-timestamp')
posts = Post.objects.select_related().extra(
select={
'username': '******',
'password': '******'
}).order_by('-timestamp')
serializer = PostSerializer(posts, many=True)
return Response(serializer.data)
def test_post_list_with_filter(self):
"""Test filtered retrieving a list of post"""
create_runnings()
res = self.client.get(POSTS_URL, {
'me': 'true',
'status': Post.Status.ERROR_PARSE
})
posts = Post.objects.filter(
last_update__isnull=False,
status=Post.Status.ERROR_PARSE).order_by('date')
serializer = PostSerializer(posts, many=True)
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertEqual(res.data['results'], serializer.data)
def test_retrieve(self):
config = {'url': '/users/1/posts/1/', 'pk': 1}
response = self.client.get(self.SERVER_NAME + config['url'],
format='json')
self.assertEqual(response.status_code, 200)
objects = Post.objects.get(pk=config['pk'])
data = PostSerializer(objects).data
content = json.loads(response.content)
self.assertEqual(content, data)
def test_list(self):
config = {'url': '/users/1/posts/', 'user_id': 1}
response = self.client.get(self.SERVER_NAME + config['url'],
format='json')
self.assertEqual(response.status_code, 200)
objects = Post.objects.filter(user_id=config['user_id'])
data = PostSerializer(objects, many=True).data
content = json.loads(response.content)
self.assertEqual(content, data)
def like_post(request):
client = get_object_or_404(Client, user=request.user)
data = request.data
post_id = data['post']
post = get_object_or_404(Post, id=post_id)
message = ""
if client in post.likes.all():
message = "Successfully removed like"
post.likes.remove(client)
else:
message = "Successfully added like"
post.likes.add(client)
post.save()
return Response({"success": message, 'post': PostSerializer(post).data})
def _analyze_post_text(text: str, text_hash: str, last_sum_distance: int,
last_post_number: int, post: Post,
event_type: EventType) -> bool:
parser_out = message_parser.parse(text)
post.text = text
post.text_hash = text_hash
if parser_out:
distance = parser_out.distance
new_sum_distance = last_sum_distance + distance
if parser_out.start_sum_number == last_sum_distance:
if new_sum_distance == parser_out.end_sum_number:
status = Post.Status.SUCCESS
else:
status = Post.Status.ERROR_SUM
else:
status = Post.Status.ERROR_START_SUM
number = last_post_number + 1
else:
status = Post.Status.ERROR_PARSE
number = None
distance = None
new_sum_distance = None
# Check that sum expression is changed
if (post.number != number or post.distance != distance
or post.sum_distance != new_sum_distance or post.status != status):
post.number = number
post.distance = distance
post.sum_distance = new_sum_distance
post.status = status
post.save()
logger.debug(f' -- {event_type.name} post after analyze: {post}')
# Adding status comment for post
comment_text = _create_comment_text(post, last_sum_distance,
new_sum_distance)
_add_status_comment(post.id, comment_text)
ws_service.main_group_send(
PostSerializer(post).data, ObjectType.POST, event_type)
return parser_out is not None
def user_posts(request, pk):
"""
List all code snippets, or create a new snippet.
"""
if request.method == 'GET':
snippets = Post.objects.filter(profile=pk)
serializer = PostSerializer(snippets, many=True)
return JsonResponse(serializer.data, safe=False)
elif 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)
return JsonResponse({"Method Not Allowed": "True"}, status=405)
def test_update(self):
config = {
'url': '/users/1/posts/1/',
'pk': 1,
'payload': {
'id': 1,
'user': 1,
'content': 'Hai bosulica',
},
}
response = self.client.put(self.SERVER_NAME + config['url'],
config['payload'],
format='json')
serializer = PostSerializer(Post.objects.get(pk=config['pk']))
self.assertEqual(response.status_code, 200)
for key, value in config['payload'].items():
self.assertEqual(value, serializer.data[key])
def main_posts(request):
# get the client that did the request
client = get_object_or_404(Client, user=request.user)
# get the blogs that the client subscribed and order the posts by recent
post_blogs = Blog.objects.filter(subs__in=[client])
posts = Post.objects.filter(blog__in=post_blogs).order_by("-date")
search = request.GET.get("search")
choice = request.GET.get("order")
order = request.GET.get("orderBy")
if search is None:
search = ""
posts = (Post.objects.filter(title__contains=search, blog__in=post_blogs) \
| Post.objects.filter(client__user__username__contains=search, blog__in=post_blogs))
if order == "asc":
order = ""
elif order == "desc":
order = "-"
if choice == "recent":
posts = posts.order_by(order + "date")
elif choice == "likes":
posts = posts.annotate(count=Count("likes")).order_by(order + "count")
elif choice == "comments":
posts = posts.annotate(count=Count("comment")).order_by(order +
"count")
posts = PostSerializer(posts, many=True).data
for post in posts:
if client.id in post['likes']: # post.likes:
post['liked'] = True
return Response(posts)
def post(self, request, format=None):
serializer = PostSerializer(data=request.data)
if serializer.is_valid():
serializer.save(owner=request.user)
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def get(self, request):
post = Post.objects.filter(
Q(user_id__in=request.user.profile.get_followers)
| Q(user_id=request.user.id))
ser = PostSerializer(post, many=True)
return Response(ser.data)
def get(self, request):
tweets = Post.objects.filter(user=request.user)
ser = PostSerializer(tweets, many=True).data
return Response(ser)
def get(self, request):
tweets = Post.objects.all()
ser = PostSerializer(tweets, many=True)
return Response(ser.data)
def retrieve(self, request, *args, **kwargs):
post = Post.objects.filter(id=kwargs['pk'])
serializer = PostSerializer(post, many=True)
return Response(serializer.data)
def post(self, request, *args, **kwargs):
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 get(self, id):
posts = Post.query.filter_by(id=id).first()
return PostSerializer(posts).data
def get(self, request):
ser = PostSerializer(Profile.objects.get(user=request.user))
return Response(ser.data)
def get(self):
posts = Post.query.all()
return PostSerializer(posts, many=True).data
def get(self, request):
obj = Post.objects.filter(user__profile__id=request.GET.get('pk'))
ser = PostSerializer(obj, many=True).data
return Response(ser)
def get(self, request, pk, format=None):
post = self.get_object(pk)
serializer = PostSerializer(post)
return Response(serializer.data)