def post(self, request):
serializer = PostSerializer(data=request.data)
if serializer.is_valid():
serializer.save(author=request.user)
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors)
def singlePost(request, uuid):
'''GET returns a single post
POST inserts a post
PUT insert/updates a post
DELETE deletes the post'''
if request.method == 'GET':
try:
post = Post.objects.get(post_id=uuid)
except:
return Response(status=status.HTTP_404_NOT_FOUND)
print(post)
serializer = PostSerializer(post)
return Response({"post": serializer.data})
# elif request.method == 'POST':
# form = PostForm(data=request.POST)
# print(form.errors)
# if form.is_valid():
# post = form.save(commit=False)
# post.author = Author.objects.get(user=request.user.id)
# post.published = timezone.now()
# post.save()
# print(post)
# serializer = PostSerializer(post)
# return Response({"post": serializer.data})
elif request.method == 'PUT':
try:
post = Post.objects.get(post_id=uuid)
except:
#TODO - this doesn't work
#make new post
# I don't think this should exist anymore
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
# serializer = PostSerializer(data=request.data)
# if serializer.is_valid():
# print("I want to make a new post")
# serializer.save(author=request.user)
# return Response(serializer.data)
# print("errors: %s"%serializer.errors)
# return Response(serializer.errors, 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)
elif request.method == 'DELETE':
try:
post = Post.objects.get(post_id=uuid)
deleted = Post.objects.get(post_id=uuid).delete()
return Response("Post deleted", status=status.HTTP_200_OK)
except:
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def put(self, request, pk, format=None):
note = self.get_object(pk)
if request.user.id == note.user_id:
serializer = PostSerializer(note, data=request.data, partial=True)
print(request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
else:
return Response({}, status=status.HTTP_400_BAD_REQUEST)
def put(self, request, pk):
post = get_object_or_404(Post, pk=pk)
if request.user.is_superuser or request.user.username == post.owner.username:
serializer = PostSerializer(instance=post, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_200_OK)
else:
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
else:
return Response(status=status.HTTP_401_UNAUTHORIZED)
def create(self, request, topic_id):
topic = get_object_or_404(TopicModel, pk=topic_id)
data = dict(request.data)
data['topic'] = topic.topic_id
data['user'] = request.user_id
serializer = PostSerializer(data=data)
if serializer.is_valid():
post = serializer.save()
return Response({'post_id': post.post_id}, status=201)
return Response(serializer.errors, status=422)
def post(self, request):
if request.user is not None and request.user.is_active:
request.data[u'owner'] = request.user.pk
request.data[u'published'] = True
serializer = PostSerializer(data=request.data)
if serializer.is_valid():
new_post = serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
else:
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
return Response(status=status.HTTP_401_UNAUTHORIZED)
def post_detail(request, pk):
"""
Retrieve, update or delete a code post.
"""
try:
post = Post.objects.get(pk=pk)
except Post.DoesNotExist:
return HttpResponse(status=404)
if request.method == 'GET':
serializer = PostSerializer(post)
return JsonResponse(serializer.data)
elif request.method == 'PUT':
data = JSONParser().parse(request)
serializer = PostSerializer(post, data=data)
if serializer.is_valid():
serializer.save()
return JsonResponse(serializer.data)
return JsonResponse(serializer.errors, status=400)
elif request.method == 'DELETE':
post.delete()
return HttpResponse(status=204)
def create_post(request):
try:
content = request.FILES['content']
except Exception as e:
print(e)
return {"success": False, "message": "Required param content is missing"}
try:
thumbnail = request.FILES['thumbnail']
except MultiValueDictKeyError:
thumbnail = None
kind = filetype.guess(content)
if kind is None:
return {"success": False, "message": "Can't Determine file type"}
extension = kind.extension
print(extension)
if PostFunctions.valid_extension(extension):
data = {"content": request.data.get('content'), "thumbnail": thumbnail, "caption": request.data.get("caption"), "user": request.user.id}
post = PostSerializer(data=data)
if post.is_valid():
instance = post.save()
# if not settings.DEBUG:
# AWS storage is being used
# image_url = instance.content.url
# if not settings.DEBUG:
# # if debug is false
# image_url = request.build_absolute_uri(image_url)
# remote_request = requests.get(image_url, stream=True)
# if remote_request.status_code == requests.codes.ok:
# allowed_chars = ''.join((string.ascii_letters, string.digits))
# unique_name = ''.join(random.choice(allowed_chars) for _ in range(5))
# open('upload' + unique_name + '.' +extension, 'wb').write(remote_request.content)
# file_info = mutagen.File('upload' + unique_name + '.' +extension).info.pprint()
# second = str(file_info)
# info_lst = second.split(",")
# number_of_seconds = str(info_lst[1])
# number_of_seconds = re.findall('\d*\.?\d+',number_of_seconds)
# number_of_seconds = math.floor(float(number_of_seconds[0]))
serializer = PostSerializer(instance, many=False, context={'request': request})
# if os.path.exists('upload' + unique_name + '.' +extension):
# os.remove('upload' + unique_name + '.' +extension)
# if 90 > number_of_seconds:
return {"success": True, "message": "Post Created", "data": serializer.data}
# existing = Post.objects.get(pk=serializer.data.get('id'))
# existing.delete()
return {"success": False, "message": post.errors}
return {"success": False, "message": "Invalid post content provided only Audio, video allowed"}
def update(self, request, *args, **kwargs):
post = self.get_object()
serializer = PostSerializer(post, data=request.data)
if serializer.is_valid():
post = serializer.save()
post.updated_at = datetime.utcnow()
post.save()
if settings.ENABLE_SSE:
self.redis_con.publish(settings.REDIS_SSE_CHANNEL,
sse_event("post.updated", post))
return Response(serializer.data, status=status.HTTP_200_OK)
return Response(
{
'status': 'Failed',
'message': 'Update failed with submitted data'
},
status=status.HTTP_400_BAD_REQUEST)
def create_post(self, request, **kwargs):
try:
group = Group.objects.get(**kwargs)
except Group.DoesNotExist:
return response404('Group')
self.check_object_permissions(request=request, obj=group)
serializer = PostSerializer(data=request.data, partial=True)
if not serializer.is_valid():
return response406({
**serializer.errors, 'message': 'Błąd walidacji'
})
post = serializer.save(group=group, owner=request.user)
file = request.FILES.get('file', None)
image = request.FILES.get('image', None)
if file:
post.file = file
post.save()
if image:
post.image = image
post.save()
return response200({
**serializer.data, 'message':
'Pomyślnie utworzono post'
})
def post(self, request):
try:
content = request.FILES['content']
except Exception as e:
print(e)
return Response(
{
"success": False,
"message": "Required param content is missing"
},
status=400)
try:
thumbnail = request.FILES['thumbnail']
except MultiValueDictKeyError:
thumbnail = None
kind = filetype.guess(content)
if kind is None:
return Response(
{
"success": False,
"message": "Can't Determine file type"
},
status=400)
extension = kind.extension
print(extension)
if PostFunctions.valid_extension(extension):
data = {
"content": request.data.get('content'),
"thumbnail": thumbnail,
"caption": request.data.get("caption"),
"user": request.user.id
}
post = PostSerializer(data=data)
if post.is_valid():
instance = post.save()
# file_info = mutagen.File(instance.content.path).info.pprint()
# second = str(file_info)
# info_lst = second.split(",")
# number_of_seconds = str(info_lst[1])
# number_of_seconds = re.findall('\d*\.?\d+',number_of_seconds)
# number_of_seconds = math.floor(float(number_of_seconds[0]))
serializer = PostSerializer(instance,
many=False,
context={'request': request})
# if 90 > number_of_seconds:
return Response({
"success": True,
"message": "Post Created",
"data": serializer.data
})
# existing = Post.objects.get(pk=serializer.data.get('id'))
# existing.delete()
# return Response({"success": False, "message": "content duration is greater than 90 seconds"},
# status=400)
return Response({
"success": False,
"message": post.errors
},
status=400)
return Response(
{
"success":
False,
"message":
"Invalid post content provided only Audio, video allowed"
},
status=400)
def post(self, request, format=None):
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 post_detail(request, pk):
"""
Retrieve, update or delete a Post.
"""
try:
post = Post.objects.get(pk=pk)
t = post.time_to_expire() # get time to expire
t = timezone.timedelta(seconds=int(t))
serializer = PostSerializer(post)
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)
except Post.DoesNotExist:
return Response('Post ' + str(pk) + ' Not found ')
if request.method == 'GET':
t = post.time_to_expire() # get time to expire
t = timezone.timedelta(seconds=int(t))
serializer = PostSerializer(post)
update_time(queryset_comment, t, CommentSerializer)
update_time(queryset_preference, t, PreferenceSerializer)
r = {
'Number of comments:': len(serializer.data['comments']),
'Data': serializer.data,
}
return Response(r)
elif request.method == 'PUT':
t = post.time_to_expire() # get time to expire
t = timezone.timedelta(seconds=int(t))
serializer = PostSerializer(post)
update_time(queryset_comment, t, CommentSerializer)
update_time(queryset_preference, t, PreferenceSerializer)
if serializer.data[
'status'] == 'Live': # Allow preference modification only if the post is still Live
#Check if the current user is different from post owner
if request.user.id == serializer.data['owner']: # he is the owner
data_mutable = request.data.copy() #make the QueryDict mutable
data_mutable[
'owner'] = request.user.id # set the current user as user
serializer = PostSerializer(post, data=data_mutable)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors)
else:
return Response(
'Action denied! you are not owner of the post. the owner Id is: '
+ str(serializer.data['owner']))
else:
return Response('Action denied, Post has expired')
elif request.method == 'DELETE':
#Update time to expire
t = post.time_to_expire() # get time to expire
t = timezone.timedelta(seconds=int(t))
serializer = PostSerializer(post)
update_time(queryset_comment, t, CommentSerializer)
update_time(queryset_preference, t, PreferenceSerializer)
if serializer.data[
'status'] == 'Live': # Allow preference modification only if the post is still Live
if request.user.id == serializer.data['owner']: # he is the owner
post.delete()
r = {
'message': 'Successfully Deleted',
}
return Response(r)
else:
return Response(
'Action can not performed! you are not owner of the post. the owner Id is: '
+ str(serializer.data['owner']))
else:
return Response('Action denied, Post has expired')
def preference_details(request,pk,pk1):
'''
Change your Preference for post pk, preference pk1. Input should be in the format:
{"value": "Like" / "Dislike" chose preference action}
'''
try:# Fectch the specific post
post = Post.objects.get(pk=pk)
#Update time_to_expire_field
t=post.time_to_expire()# get time to expire
t=timezone.timedelta(seconds=int(t))
serializer = PostSerializer(post)
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)
except Post.DoesNotExist:
return Response('Post '+str(pk) + ' Not found ')
try:# Fetch the specific preference
preference = Preference.objects.get(pk=pk1)
except Preference.DoesNotExist:
return Response('Preference '+str(pk1) + ' Not found ')
if request.method == 'GET':
#Update time_to_expire_field
t=post.time_to_expire()# get time to expire
t=timezone.timedelta(seconds=int(t))
serializer = PostSerializer(post)
update_time(queryset_comment,t,CommentSerializer)
update_time(queryset_preference,t,PreferenceSerializer)
serializer_pref=PreferenceSerializer(preference)
r = {
'Post Title:': serializer.data['title'],
'Post Owner:': serializer.data['owner'],
'Post Status:': serializer.data['status'],
'Preference Detail': serializer_pref.data,}
return Response(r)
elif request.method == 'PATCH':
t=post.time_to_expire()# get time to expire
t=timezone.timedelta(seconds=int(t))
serializer = PostSerializer(post)
update_time(queryset_comment,t,CommentSerializer)
update_time(queryset_preference,t,PreferenceSerializer)
if serializer.data['status'] == 'Live':# Allow preference modification only if the post is still Live
serializer_pref=PreferenceSerializer(preference)
data_mutable=request.data.copy()#make the QueryDict mutable
data_mutable['owner']=request.user.id # set the current user as user
if data_mutable['owner']==serializer_pref.data['owner']:# Allow modification only if the user is the owner of the preference
serializer_pref_new=PreferenceSerializer(preference,data=data_mutable,partial=True)
if serializer_pref_new.is_valid():
if request.data['value']==serializer_pref.data['value']:
return Response('You have already made a :' + request.data['value'])
else:#perform the update
#update the number of likes dislike to the post related to the preference
#Update the likes/ dislikes in Post
like=serializer.data['likes']
dislike=serializer.data['dislikes']
if request.data['value'] == 'Like':
like+=1
dislike-=1
else:
dislike+=1
like-=1
serializer = PostSerializer(post, data=serializer.data)
if serializer.is_valid():
serializer.save(likes=like,dislikes=dislike)
else:
return Response(serializer.errors)
serializer_pref_new.save()
return Response(serializer_pref_new.data)
else:
return Response(serializer_pref_new.errors)
else:# User not owner of the preference
return Response('Action denied, You are not the owner of this preference')
else:#Post expired
return Response('Action denied, Post has expired')
elif request.method == 'DELETE':
#Update time to expire
t=post.time_to_expire()# get time to expire
t=timezone.timedelta(seconds=int(t))
serializer = PostSerializer(post)
update_time(queryset_comment,t,CommentSerializer)
update_time(queryset_preference,t,PreferenceSerializer)
serializer_pref=PreferenceSerializer(preference)
if serializer.data['status'] == 'Live':# Allow preference modification only if the post is still Live
if request.user.id == serializer_pref.data['owner']: #he is the owner
preference.delete()
#Update the number of likes
like=serializer.data['likes']
dislike=serializer.data['dislikes']
if serializer_pref.data['value'] == 'Like':
like-=1
else:
dislike-=1
serializer = PostSerializer(post, data=serializer.data)
if serializer.is_valid():
serializer.save(likes=like,dislikes=dislike)
else:
return Response(serializer.errors)
r = {
'message': 'Successfully Deleted',
}
return Response(r)
else:
return Response('Action can not performed! you are not owner of the preference. the owner Id is: ' + str(serializer_pref.data['owner']))
else:
return Response('Action denied, Post has expired')
def post_preference(request,pk):
'''
Create a Preference to the post pk. Input should be in the format:
{"value": "Like" / "Dislike" chose preference action}
'''
try:
#Update time_to_expire_field
post = Post.objects.get(pk=pk)
t=post.time_to_expire()# get time to expire
t=timezone.timedelta(seconds=int(t))
serializer = PostSerializer(post)
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)
except Post.DoesNotExist:
return Response('Post '+str(pk) + ' Not found ')
if request.method == 'GET':
#Update time_to_expire_field
t=post.time_to_expire()# get time to expire
t=timezone.timedelta(seconds=int(t))
serializer = PostSerializer(post)
update_time(queryset_comment,t,CommentSerializer)
update_time(queryset_preference,t,PreferenceSerializer)
serializer_set=PreferenceSerializer(queryset_preference, many=True)
r = {
'Post Title:': serializer.data['title'],
'Post Owner:': serializer.data['owner'],
'Post Status:': serializer.data['status'],
'Preferences': serializer_set.data,}
return Response(r)
elif request.method == 'POST':
#Update time_to_expire_field
t=post.time_to_expire()# get time to expire
t=timezone.timedelta(seconds=int(t))
serializer = PostSerializer(post)
update_time(queryset_comment,t,CommentSerializer)
update_time(queryset_preference,t,PreferenceSerializer)
if serializer.data['status'] == 'Live':# Allow post preference only if the post is still Live
data_mutable=request.data.copy()#make the QueryDict mutable
data_mutable['owner']=request.user.id # set the current user as user
#request.data['owner']=request.user.id # set the current user as user
if request.user.id!=serializer.data['owner']:# Allow the post since the current user is different from the post owner
#Create preference
data_mutable['post']=serializer.data['id']
data_mutable['time_to_expire']=t
pref_serializer = PreferenceSerializer(data=data_mutable)
# Check if user has already liked the post
if not(check_preference_exist(queryset_preference,data_mutable['owner'],data_mutable['post'])): # the current user did not like the post already
if pref_serializer.is_valid():
pref_serializer.save(owner=request.user)# set the current user as user
r = {
'User ID': request.user.id,
'message': 'Successfully created preference',
'Data': pref_serializer.data,}
#Update the likes/ dislikes in Post
like=serializer.data['likes']
dislike=serializer.data['dislikes']
if data_mutable['value'] == 'Like':
like+=1
else:
dislike+=1
serializer = PostSerializer(post, data=serializer.data)
if serializer.is_valid():
serializer.save(likes=like,dislikes=dislike)
return Response(r)
return Response(serializer.errors)
return Response(pref_serializer.errors)
else: #the current user did a preference for the post already
return Response(['Action denied, you interracted with the post already if you want to change your preference please select it and patch it'])
else:# Current user is the post owner
return Response('Action denied, you are the owner of the Post')
else: # Post is expired
return Response('Action denied, Post has expired')
