def get_all_posts(request):
"""
Retorna um json com todos os post cadastrados
"""
response = {
"status": "failure",
}
if request.method == 'GET':
posts = Post.objects.all()
serializer = PostSerializer(posts, many=True)
response = {
"status": "success",
"shows": serializer.data,
}
return Response(response)
elif request.method == 'POST':
serializer = PostSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
response = {
"status": "success",
"shows": serializer.data,
}
return Response(response, status=status.HTTP_201_CREATED)
response = {
"status": "failure",
"errors": serializer.errors,
}
return Response(response, status=status.HTTP_400_BAD_REQUEST)
return Response(response)
def post_list(request):
if request.method == 'GET':
posts = Post.objects.all()
serializer = PostSerializer(posts, many=True)
return Response(serializer.data)
if request.method == 'POST':
serializer = PostSerializer(data=request.DATA)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(request):
if request.method == 'GET':
posts = Post.objects.all()
serializer = PostSerializer(posts, many=True)
return Response(serializer.data, status=status.HTTP_200_OK)
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_500_INTERNAL_SERVER_ERROR)
def get(self, request, pk=None):
posts = Post.objects.all()
if pk:
try:
post = posts.get(pk=pk)
except ObjectDoesNotExist:
return Response({'error': 'Post not found with {}'.format(pk)},
status=404)
post = PostSerializer(post)
return Response(post.data)
posts = Post.objects.all()
posts = PostSerializer(posts, many=True)
return Response(posts.data)
def posts(request):
if request.method == 'GET':
queryset = Post.objects.all()
serializer = PostSerializer(queryset, many=True)
return JsonResponse(serializer.data, safe=False)
elif request.method == 'POST':
parser = JSONParser()
data = parser.parse(request)
post = PostSerializer(data=data)
if post.is_valid():
post.save(user=request.user)
return JsonResponse(post.data, status=201)
return JsonResponse(post.errors, status=400)
def get(self, request, post_id):
is_local = is_local_request(request)
response_object = {"query": "getPost", "post": None}
#first we check to see if the post with the id exists
try:
post = Post.objects.get(pk=post_id) # pylint: disable=maybe-no-member
except:
return Response(response_object, status=status.HTTP_404_NOT_FOUND)
if not is_sharePosts(is_local, request.user):
return Response(response_object, status=403)
if not is_shareImgs(is_local, request.user):
if post.contentType == 'image/png;base64' or post.contentType == 'image/jpeg;base64':
return Response(status=403)
#if the posts visibility is set
#to PUBLIC, we are ok to return it
if (post.visibility == "PUBLIC"):
serializer = PostSerializer(post)
response_object = serializer.data
return Response(response_object, status=status.HTTP_200_OK)
#otherwise, the other privacy settings
#require that an author be logged in
# lets check if an author is logged in first
# here, author has to login in order to view the posts,
try:
author = get_request_author(is_local, request)
except:
return Response(response_object, status=status.HTTP_403_FORBIDDEN)
#check if its the currently authenticated
#users post
if (author.id == post.postauthor.id):
serializer = PostSerializer(post)
response_object = serializer.data
return Response(response_object, status=status.HTTP_200_OK)
check_permissions = CheckPermissions(author, post)
# if current author has no permission:
if (not check_permissions[1]):
return Response(response_object, status=status.HTTP_403_FORBIDDEN)
# current user has permission
serializer = PostSerializer(post)
response_object = serializer.data
return Response(response_object, status=status.HTTP_200_OK)
def published_list(request):
if request.method == 'GET':
# def get_queryset(self):
posts = Post.objects.filter(is_published=True)
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({'error': serializer.errors},
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def post(self, request):
serialized = PostSerializer(data=request.data)
if serialized.is_valid(raise_exception=True):
serialized.save()
response = {"data": serialized.data}
return Response(response, status=201)
return Response({"message": "Error - not created"}, status=400)
def put(self, request, user_id, pid, format=None):
post = self.get_objects(user_id, pid)
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 api_create_blog_view(request):
account = User.objects.get(pk=1)
post = Post(author=account)
if request.method == 'POST':
serializer = PostSerializer(post, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
# User views
# @api_view(['POST'])
# def api_registration_view(request):
# if request.method == 'POST':
# serializer = RegistrationSerializer(data=request.data)
# data = {}
# if serializer.is_valid():
# user = serializer.save()
# data['response'] = 'successfully registered a new user'
# data['email'] = user.email
# data['username'] = user.username
# else:
# data = serializer.errors
# return Response(data)
def create(self, request, *args, **kwargs): # Upload image to server if needed and create post
data = request.data.copy()
posts_count = Post.objects.filter(topic_id=data['topic_id'], creator=data['creator_id']).count()
if posts_count >= MAX_POSTS_ALLOWED:
return Response(status=status.HTTP_403_FORBIDDEN)
if data['topic_id'] is None:
return Response(status=status.HTTP_400_BAD_REQUEST)
topic = Topic.objects.get(pk=data['topic_id'])
if not topic.is_active():
return Response(status=status.HTTP_403_FORBIDDEN)
images_dir = './images/'
image_name = '{}_{}'.format(request.data['creator_id'], timezone.now().strftime("%Y_%m_%d_%H_%M_%S"))
image_extension = request.data['extension']
if '.' not in image_extension:
image_extension = '.' + image_extension
full_path = '{}{}{}'.format(images_dir, image_name, image_extension)
if not os.path.exists(images_dir):
os.makedirs(images_dir)
image = data['image']
decoded = base64.b64decode(image)
with open(full_path, "wb") as fh:
fh.write(decoded)
fh.close()
image = Image.objects.create(uri=full_path)
post = Post.objects.create(description=data['description'], title=data['title'],
creator_id=data['creator_id'], topic_id=data['topic_id'], image_id=image.id)
serializer = PostSerializer(instance=post)
return Response(serializer.data, status=status.HTTP_201_CREATED)
def post_add(request):
if request.method == 'PUT':
data = JSONParser().parse(request)
if 'post_data' in data:
hash = calcHash(data['post_data'])
data['post_uniqueCode'] = hash
else:
return HttpResponse("Bad syntax", status=400)
serializer = PostSerializer(data=data)
if serializer.is_valid():
try:
post = Post.objects.get(
post_uniqueCode=data['post_uniqueCode'])
if post != None:
return HttpResponse(
"post with requested code already exists", status=409)
except Post.DoesNotExist:
serializer.save()
id = serializer.data['post_id']
return HttpResponse(str(id), status=200)
else:
return HttpResponse("Bad syntax", status=400)
else:
return HttpResponse(status=404)
def get(self, request, pk):
post = Post.objects.filter(id=pk)
serializer = PostSerializer(post, many=True)
return Response({"response": serializer.data},
status=status.HTTP_200_OK)
def get(self, request):
posts = Post.objects.all()
serializer = PostSerializer(posts, many=True)
return Response({"response": serializer.data},
status=status.HTTP_200_OK)
def post(self, request):
serializer = PostSerializer(data=request.data)
print(request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def get(self, request, id, format=None):
try:
item = Post.objects.get(pk=id)
serializer = PostSerializer(item)
return Response(serializer.data)
except Post.DoesNotExist:
return Response(status=404)
def post(self, request):
data = JSONParser().parse(request)
serialized = PostSerializer(data=data)
if serialized.is_valid():
serialized.save()
return JsonResponse(serialized.data, status=status.HTTP_201_CREATED)
def get(self, request):
is_local = is_local_request(request)
response_object = {
"query": "getPosts",
"count": None,
"size": None,
"next": None,
"previous": None,
"posts": None
}
if not is_sharePosts(is_local, request.user):
return Response(status=403)
request_url = request.build_absolute_uri("/").strip("/")
previous_page = None
#start off by getting the
#page and size from the query string
try:
page = int(request.GET.get("page", ""))
except:
page = ""
try:
size = int(request.GET.get("size", ""))
except:
size = ""
posts = Post.objects.filter(visibility="PUBLIC",
unlisted=False).order_by('published') # pylint: disable=maybe-no-member
if not is_shareImgs(is_local, request.user):
posts = posts.exclude(
Q(contentType='image/png;base64')
| Q(contentType='image/jpeg;base64'))
count = posts.count()
if (page and size):
paginator = Paginator(posts, size)
if (page > paginator.num_pages):
posts = None
else:
posts = paginator.get_page(page)
response_object["size"] = size
if (page > 1):
previous_page = request_url + "/posts?page={}&size={}".format(
page - 1, size)
next_page = request_url + "/posts?page={}&size={}".format(
page + 1, size)
response_object["next"] = next_page
response_object["previous"] = previous_page
serializer = PostSerializer(posts, many=True)
response_object["posts"] = serializer.data
response_object["count"] = count
return Response(response_object, status=status.HTTP_200_OK)
def put(self, request, id):
post = self.get_post(id)
serializer = PostSerializer(instance=post, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response({'error': serializer.errors})
def put(self, request, id):
post = self.get_object(id)
serializer = PostSerializer(post, data=request.data, partial=True)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def list(self, request):
permission_classes = (IsAuthenticated, )
try:
queryset = Post.objects.filter(author=request.user)
serializer = PostSerializer(queryset, many=True)
return Response(serializer.data)
except:
raise PermissionDenied({"error": "Must be logged"})
def post(self, request): #Allows user to create a new post
serializer = PostSerializer(data=request.data)
if serializer.is_valid():
serializer.save(
owner=request.user) #Turns data into actual book object
return Response(serializer.data, status=201)
return Response(serializer.errors, status=400)
def get(self, request, pk):
queryset = Post.objects.filter(author=pk)
# Passed context needed for HyperLinked within serializer.
serializer = PostSerializer(queryset,
many=True,
context={'request': request})
return Response(serializer.data)
def post_list(request):
if request.method == 'POST':
posts = Post.objects.all().order_by('-like_users')
result = []
for item in posts:
serializer = PostSerializer(item)
result.append(serializer.data)
return Response(data=result, status=status.HTTP_200_OK)
def get(self, request, pk, format=None):
content = {
'user':
unicode(request.user), # `django.contrib.auth.User` instance.
'auth': unicode(request.auth), # None
}
post = self.get_object(pk)
serializer = PostSerializer(post)
return Response(serializer.data)
def post_detail(request, pk):
try:
post = Post.objects.get(id=pk)
except Post.DoesNotExist:
return Response(status=status.HTTP_404_NOT_FOUND)
if request.method == 'GET':
serializer = PostSerializer(post)
return Response(serializer.data)
elif request.method == 'PUT':
serializer = PostSerializer(instance=post, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors)
elif request.method == 'DELETE':
post.delete()
return Response(status=status.HTTP_204_NO_CONTENT)
def api_detail_blog_view(request, pk):
try:
post = Post.objects.get(pk=pk)
except Post.DoesNotExist:
return Response(status=status.HTTP_404_NOT_FOUND)
if request.method == 'GET':
serializer = PostSerializer(post)
return Response(serializer.data)
def postList(request):
if request.method == "GET":
posts = PostModel.objects.all()
serialized = PostSerializer(posts, many=True)
return JsonResponse(serialized.data, safe=False)
else:
return JsonResponse(None, status=400)
def post(self, request, pk):
post = self.get_object(pk)
post.like_count += 1
request.data['title'] = post.title
serializer = PostSerializer(instance=post, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors)
def post(self, request, id):
category = self.get_category(id)
profile = Profile.objects.get(user=self.request.user)
serializer = PostSerializer(data=request.data)
if serializer.is_valid():
serializer.save(category=category, author_id=profile.id)
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response({'error': serializer.errors},
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
