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 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):
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 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 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, 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 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 post_list(request, format=None):
"""
List all post or create new post
"""
if request.method == 'GET':
posts = Post.objects.all()
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 list(request):
"""
List all code posts, or create a new post.
"""
if request.method == 'GET':
posts = Post.objects.all()
serializer = PostSerializer(posts, many=True)
return Response(serializer.data)
elif request.method == 'POST':
link_file = uploadFile(request.FILES['file'])
request.data["file"] = link_file
post = PostSerializer(data=request.data)
if post.is_valid():
post.save()
return Response(post.data, status=status.HTTP_201_CREATED)
def post_detail(request, pk, format=None):
"""
List all post or create new post
"""
try:
posts = Post.objects.get(pk=pk)
except Snippet.DoesNotExist:
return Response(status=status.HTTP_404_NOT_FOUND)
if request.method == 'GET':
serializer = PostSerializer(posts, many=True)
return Response(serializer.data)
elif request.method == 'PUT':
serializer = PostSerializer(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':
posts.delete()
return Response(status=status.HTTP_204_NO_CONTENT)
def post(self, request, *args, **kwargs):
posts_serializer = PostSerializer(data=request.data)
if posts_serializer.is_valid():
posts_serializer.save()
hog_det.hog('/home/ritodeep/Desktop/form-data/backend'+posts_serializer.data['image'])
# img = open('/home/ritodeep/Desktop/form-data/backend/media/HOG_Test/Faces.jpg','rb')
responseImg = utils.convert('/home/ritodeep/Desktop/form-data/backend/media/HOG_Test/Faces.jpg')
return Response(responseImg)
try:
with open('/home/ritodeep/Desktop/form-data/backend/media/HOG_Test/Faces.jpg', "rb") as f:
return JsonResponse(f.read(), content_type="image/jpeg",safe=False)
except IOError:
red = Image.new('RGBA', (1, 1), (255,0,0,0))
response = HttpResponse(content_type="image/jpeg")
red.save(response, "JPEG")
return response
else:
print('error', posts_serializer.errors)
return Response(posts_serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def vote(request, id):
# print(request)
try:
post = Post.objects.get(id=id)
except Post.DoesNotExist:
return Response(status=status.HTTP_404_NOT_FOUND)
if request.method == "GET":
serializer = PostSerializer(post)
return Response(serializer.data, status=status.HTTP_200_OK)
if request.method == 'PUT':
# print(id)
# print(request.data)
serializer = PostSerializer(post, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_202_ACCEPTED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
return Response(status=status.HTTP_404_NOT_FOUND)
def create(self, request):
serializer_class = PostSerializer(data=request.data)
if serializer_class.is_valid():
serializer_class.save()
return Response(serializer_class.data)
return Response({'error': 'INVALID REQUEST'})
def get_visible_posts(author_id):
author = get_object_or_404(Author, id=author_id)
nodes = list(Node.objects.all())
visible_posts = Post.objects.none()
for node in nodes:
if node.node_auth_username != "":
# We have a set username and password to authenticate with this node.
# We send a GET request to their endpoint.
url = node.api_url + 'author/posts'
try:
response = requests.get(url,
auth=(node.node_auth_username,
node.node_auth_password),
headers={
'content-type': 'application/json',
'Accept': 'application/json'
},
timeout=settings.GLOBAL_TIMEOUT)
except Timeout:
print("Request to", url, "timed out")
return filter_posts(visible_posts, author_id)
if response.status_code == 200:
# print(response.json())
# We have the geen light to continue. Otherwise, we just use what we have cached.
posts_json = response.json()
for post in posts_json["posts"]:
# We first have to ensure the author of each post is in our database.
# If they aren't a node we can talk with, then it shouldn't be on this site.
if len(
Node.objects.filter(hostname=post['origin'].split(
'posts/')[0])) == 1:
author = sanitize_author(post["author"])
post = sanitize_post(post)
post = transformSource(post)
author['displayName'] = author['displayName'] + \
" (" + node.server_username + ")"
author_parts = author['id'].split('/')
authorID = author_parts[-1]
if authorID == '':
authorID = author_parts[-2]
# Our author URLS need a UUID, so we have to check if it's not
# The author's ID should never change!
try:
uuid.UUID(authorID)
author['url'] = settings.FORMATTED_HOST_NAME + \
'author/' + authorID
except:
# We need to create a new one for the URL
if len(Author.objects.filter(
id=author["id"])) == 1:
# We already made one for them
author['url'] = Author.objects.get(
id=author["id"]).url
else:
# Give them a new one.
author['url'] = settings.FORMATTED_HOST_NAME + \
'author/' + str(uuid.uuid4().hex)
# Check if we already have that author in our db
# already. If so, update it.
if (len(Author.objects.filter(id=author['id'])) == 1):
old_author = Author.objects.get(id=author['id'])
author_serializer = AuthorSerializer(old_author,
data=author)
else:
author_serializer = AuthorSerializer(data=author)
if author_serializer.is_valid():
try:
author_serializer.save()
# print("saved author")
# We now have the author saved, so we can move on to the posts
if len(Post.objects.filter(
id=post["id"])) == 1:
post_serializer = PostSerializer(
Post.objects.get(id=post["id"]),
data=post)
else:
post_serializer = PostSerializer(data=post)
if post_serializer.is_valid():
try:
post_serializer.save()
# print("Loaded post",
# post_serializer.validated_data["title"])
visible_posts = visible_posts | Post.objects.filter(
id=post_serializer.
validated_data["id"])
except Exception as e:
print(
"Error saving post",
post_serializer.
validated_data["title"], str(e))
else:
print("Error encountered:",
post_serializer.errors)
except Exception as e:
print(e)
else:
continue
# Filter returned posts to return only those this author can see
return filter_posts(visible_posts, author_id)
def get_detailed_post(post_id):
# Assumes that the post is already in our DB due to the fact that you are passing an ID.
local_copy = get_object_or_404(Post, id=post_id)
if (local_copy.origin != local_copy.source):
local_split = local_copy.origin.split('/')
# Ignore github posts
if local_split[2] == 'api.github.com':
return local_copy
node = Node.objects.get(hostname__contains=local_split[2])
url = node.api_url + 'posts/' + local_split[-1]
try:
response = requests.get(url,
auth=(node.node_auth_username,
node.node_auth_password),
headers={
'content-type': 'application/json',
'Accept': 'application/json'
},
timeout=settings.GLOBAL_TIMEOUT)
except Timeout:
print("Request to", url, "timed out")
return None
if response.status_code == 404:
# The post is gone!
Post.objects.get(id=post_id).delete()
return None
if response.status_code == 200:
post_json = response.json()
# TODO: Talk to Group 4 about how to consistently do the detailed post endpoint
if 'post' not in post_json.keys():
# If 'post' is not in there, then the data is likely sent without being wrapped
post_json['post'] = post_json
if 'posts' in post_json.keys():
# We have to add an exception here if this list is empty. Group 4 is doing some weird stuff.
if len(post_json["posts"]) == 0:
# We have no post to update from.
# This is now how team 4 tells us the post does not exist >:(
Post.objects.get(id=post_id).delete()
return None
post_json["post"] = post_json["posts"][0]
del post_json["posts"]
post_data = post_json['post']
if type(post_data) == type(['foo']):
post_data = post_data[0]
# Let us sanitize the author
post_data["author"] = sanitize_author(post_data["author"])
post = sanitize_post(post_data)
post_data = transformSource(post_data)
post_serializer = PostSerializer(local_copy, data=post)
if post_serializer.is_valid():
# print("it is valid")
try:
post_serializer.save()
# print("Updated post",
# post_serializer.validated_data["title"])
new_copy = get_object_or_404(
Post, id=post_serializer.validated_data["id"])
return new_copy
# new_copy = Post.objects.filter(
# id=)
except Exception as e:
print("Error saving post",
post_serializer.validated_data["title"], str(e))
else:
print("Error encountered:", post_serializer.errors)
return local_copy
# If it gets this far, return what is cached.
return local_copy
def get_public_posts():
# Returns a QuerySet of all the public posts retrieved from http://service/posts
# print("running")
nodes = list(Node.objects.all())
public_posts = Post.objects.none()
for node in nodes:
if node.node_auth_username != "":
# We have a set username and password to authenticate with this node.
# We send a GET request to their endpoint.
url = node.api_url + 'posts'
# print("sending to ", url)
# response = requests.get(
# url, auth=(
# node.node_auth_username, node.node_auth_password), headers={'content-type': 'application/json', 'Accept': 'application/json'})
response = requests.get(url,
auth=(node.node_auth_username,
node.node_auth_password),
headers={
'content-type': 'application/json',
'Accept': 'application/json'
},
timeout=settings.GLOBAL_TIMEOUT)
if response.status_code == 200:
# print(response.json())
# We have the geen light to continue. Otherwise, we just use what we have cached.
posts_json = response.json()
for post in posts_json["posts"]:
# We first have to ensure the author of each post is in our database.
# We should not have these posts in our database if they are from a site we have no connection to.
hostname = post['origin'].split('posts/')[0]
if len(Node.objects.filter(hostname=hostname)) == 1:
author = sanitize_author(post["author"])
post = sanitize_post(post)
post = transformSource(post)
author['displayName'] = author['displayName'] + \
" (" + node.server_username + ")"
author_parts = author['id'].split('/')
authorID = author_parts[-1]
if authorID == '':
authorID = author_parts[-2]
# Our author URLS need a UUID, so we have to check if it's not
# The author's ID should never change!
try:
uuid.UUID(authorID)
author['url'] = settings.FORMATTED_HOST_NAME + \
'author/' + authorID
except:
# We need to create a new one for the URL
if len(Author.objects.filter(
id=author["id"])) == 1:
# We already made one for them
author['url'] = Author.objects.get(
id=author["id"]).url
else:
# Give them a new one.
author['url'] = settings.FORMATTED_HOST_NAME + \
'author/' + str(uuid.uuid4().hex)
if (len(Author.objects.filter(id=author['id'])) == 1):
old_author = Author.objects.get(id=author['id'])
author_serializer = AuthorSerializer(old_author,
data=author)
else:
author_serializer = AuthorSerializer(data=author)
if author_serializer.is_valid():
try:
author_serializer.save()
# print("saved author",
# author_serializer.validated_data["displayName"])
# We now have the author saved, so we can move on to the posts
if len(
Post.objects.filter(
origin=post["origin"])) == 1:
post_serializer = PostSerializer(
Post.objects.get(
origin=post["origin"]),
data=post)
else:
post_serializer = PostSerializer(data=post)
if post_serializer.is_valid():
try:
post_serializer.save()
# print("Loaded post",
# post_serializer.validated_data["title"])
public_posts = public_posts | Post.objects.filter(
id=post_serializer.
validated_data["id"])
except Exception as e:
print(
"Error saving post",
post_serializer.
validated_data["title"], str(e))
else:
print("Error encountered:",
post_serializer.errors)
except Exception as e:
print(e)
else:
print("Error encountered:",
author_serializer.errors)
else:
continue
return public_posts