def message_list(request, sender=None, receiver=None):
"""
List all required messages, or create a new message.
"""
if request.method == 'GET':
messages = Message.objects.filter(
sender_id=sender, receiver_id=receiver) | Message.objects.filter(
sender_id=receiver, receiver_id=sender)
for message in messages:
message.is_read = True
message.save()
print(messages)
serializer = MessageSerializer(messages,
many=True,
context={'request': request})
return JsonResponse(data={"messages": serializer.data}, status=200)
elif request.method == 'POST':
data = JSONParser().parse(request)
try:
data['sender'] = User.objects.get(id=int(data['sender']))
except:
return JsonResponse(data={'message': 'User does not exisit'},
status=404)
try:
data['receiver'] = User.objects.get(id=int(data['receiver']))
except:
return JsonResponse(data={'message': 'User does not exisit'},
status=404)
serializer = MessageSerializer(data=data)
if serializer.is_valid():
serializer.save()
return JsonResponse(serializer.data, status=201)
return JsonResponse(serializer.errors, status=400)
def post(self, request):
data = JSONParser().parse(request)
serializer = MessageSerializer(data=data)
if serializer.is_valid():
serializer.save()
return JsonResponse(serializer.data, status=201)
return JsonResponse(serializer.errors, status=400)
def message_details(request, value):
try:
message = Message.objects.get(id=value)
except Message.DoesNotExist:
return HttpResponse(status=404)
if request.method == 'GET':
serializer = MessageSerializer(message)
return JsonResponse(serializer.data, safe=False, status=200)
elif request.method == 'PUT':
data = JSONParser().parse(request)
serializer = MessageSerializer(message, data=data)
if serializer.is_valid():
serializer.save()
return JsonResponse(serializer.data, status=200)
return JsonResponse(serializer.errors, status=204)
elif request.method == 'DELETE':
try:
message.delete()
return HttpResponse(status=200)
except:
return HttpResponse(status=409)
def message_list(request, sender=None, receiver=None):
"""
List all required messages, or create a new message.
"""
if request.method == 'GET':
messages = Message.objects.filter(sender_id=sender,
receiver_id=receiver,
is_read=False)
serializer = MessageSerializer(messages,
many=True,
context={'request': request})
for message in messages:
message.is_read = True
message.save()
alls = User.objects.all()
print(alls)
return JsonResponse(serializer.data, safe=False)
elif request.method == 'POST':
data = JSONParser().parse(request)
serializer = MessageSerializer(data=data)
if serializer.is_valid():
serializer.save()
return JsonResponse(serializer.data, status=201)
return JsonResponse(serializer.errors, status=400)
def message_list(request, sender=None, receiver=None):
if request.method == 'GET':
messages = Message.objects.filter(sender_id=sender,
receiver_id=receiver,
is_read=False)
print(messages)
serializer = MessageSerializer(messages,
many=True,
context={'request': request})
for message in messages:
message.is_read = True
message.save()
return JsonResponse(serializer.data, safe=False)
elif request.method == 'POST':
data = JSONParser().parse(request)
x = str(data['message'])
x = vectorizer.transform([x])
data['sentiment'] = ' '.join(map(str,
label.classes_[model.predict(x)]))
serializer = MessageSerializer(data=data)
if serializer.is_valid():
serializer.save()
return JsonResponse(serializer.data, status=201)
return JsonResponse(serializer.errors, status=400)
def post(self, request, username=None):
User = get_user_model()
user = get_object_or_404(User, username=username)
serializer = MessageSerializer(data=request.data)
if serializer.is_valid():
serializer.save(sender_name=request.user, receiver_name = user)
return Response(serializer.data, status = status.HTTP_201_CREATED)
else:
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def message_post(request):
if request.method == 'POST':
user = request.user
data = {}
message = Message(sender=user)
serializer = MessageSerializer(message, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
data['error'] = serializer.errors
return Response(data=data, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, format=None):
data = request.DATA
if data.get('id'):
#no modification of posts allowed
return HttpResponseForbidden()
ser = MessageSerializer(data=data, partial=True)
if ser.is_valid():
ser.object.writer = request.user
ser.save()
ser.data['children'] = []
return Response(ser.data)
def message_list(request, sender=None, receiver=None):
if request.method == 'GET': # 메세지 리스트
messages = Message.objects.filter(sender_id=sender, receiver_id=receiver)
messages2 = Message.objects.filter(sender_id=receiver, receiver_id=sender)
allmessage = messages | messages2
serializer = MessageSerializer(allmessage, many=True, context={'request': request})
return JsonResponse(serializer.data, safe=False)
elif request.method == 'POST': #메세지 전송
data = JSONParser().parse(request)
serializer = MessageSerializer(data=data)
if serializer.is_valid():
serializer.save()
return JsonResponse(serializer.data, status=201)
return JsonResponse(serializer.errors, status=400)
def add_message_attachment(request):
data = {}
attachment = request.data.get('attachment', None)
author = request.data.get('author')
if attachment and author:
kind = attachment.content_type
if "image" in kind or "video" in kind:
data['attachment'] = attachment
else:
return Response(
data={"media": "Only video/image file is supported for now."},
status=status.HTTP_400_BAD_REQUEST)
serializer = MessageAttachmentSerializer(data=data)
if serializer.is_valid():
serializer.save()
create_message_serializer = MessageSerializer(
data={
"message":
f"[[ATTACHMENT]]:[[{kind}]]:{serializer.data['attachment']}",
"author": author
})
if create_message_serializer.is_valid():
create_message_serializer.save()
return Response(
{
"msg": "Success",
"instance": create_message_serializer.data
},
status=status.HTTP_200_OK)
return Response({
"msg": "error",
"errors": serializer.errors
},
status=status.HTTP_400_BAD_REQUEST)
return Response({
"msg": "error",
"errors": serializer.errors
},
status=status.HTTP_400_BAD_REQUEST)
return Response({
"msg": "errorrr",
}, status=status.HTTP_400_BAD_REQUEST)
def message_list(request):
"""
list all code messages, or create a new message.
"""
if request.method == 'GET':
messages = Message.objects.all()
serializer = MessageSerializer(messages, many=True)
return JSONResponse(serializer.data)
elif request.method == 'POST':
data = JSONParser().parse(request)
serializer = MessageSerializer(data=data)
if serializer.is_valid():
serializer.save()
return JSONResponse(serializer.data, status=201)
return JSONResponse(serializer.errors, status=400)
def message_list(request, sender=None, receiver=None):
if request.method == 'GET':
messages = Messages.objects.filter(sender_name=sender, receiver_name=receiver, seen=False)
serializer = MessageSerializer(messages, many=True, context={'request': request})
for message in messages:
message.seen = True
message.save()
return JsonResponse(serializer.data, safe=False)
elif request.method == "POST":
data = JSONParser().parse(request)
serializer = MessageSerializer(data=data)
if serializer.is_valid():
serializer.save()
return JsonResponse(serializer.data, status=201)
return JsonResponse(serializer.errors, status=400)
def post(self, request, chat):
try:
chat_object = Chat.objects.get(pk=int(chat))
user_object = User.objects.get(pk=request.user.id)
except Chat.DoesNotExist as err:
return Response({'success': False, 'error': str(err)})
except User.DoesNotExist as err:
return Response({'success': False, 'error': str(err)})
serializer = MessageSerializer(data=request.data,
context={'chat_object': chat_object, 'user_object': user_object},
partial=True)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors)
def create(self, request):
'''Send new message to chat'''
profile = Profile.objects.get(user=request.user)
serializer = MessageSerializer(data=request.data)
try:
chat = Chat.objects.get(id=request.data['chat'])
except:
message = {'detail': 'pleace, specify the \"chat\" field'}
return Response(message, status=status.HTTP_400_BAD_REQUEST)
if serializer.is_valid():
if is_chat_available(profile, chat):
serializer.save(sender=profile, chat=chat)
return Response(serializer.data,
status=status.HTTP_201_CREATED)
message = {'detail': 'user can\'t chat with unmatched users'}
return Response(message, status=status.HTTP_400_BAD_REQUEST)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def message_list(req):
if req.method == 'GET':
messages = Message.objects.all()
serializer = MessageSerializer(messages, many=True)
return JsonResponse(serializer.data, safe=False, status=200)
elif req.method == 'POST':
data = JSONParser().parse(req)
serializer = MessageSerializer(data=data)
if serializer.is_valid():
serializer.save()
return JsonResponse(serializer.data, status=201)
return JsonResponse(serializer.errors, status=204)
def create(self, request, name):
data = {
'author': request.user,
'text': request.data['text'],
'conversation': name,
}
serializer = MessageSerializer(data=data)
if serializer.is_valid():
serializer.save()
return Response(serializer.validated_data,
status=status.HTTP_201_CREATED)
else:
return Response(
{
'status': 'Bad request',
'message':
'Message could not be created with received data.'
},
status=status.HTTP_400_BAD_REQUEST)
def message_list(request, sender=None, receiver=None):
"""
List all required messages, or create a new message.
"""
if request.method == 'GET':
messages = Message.objects.filter(sender_id=sender,
receiver_id=receiver,
is_read=False)
serializer = MessageSerializer(messages, many=True)
for message in messages:
message.is_read = True
message.save()
return Response(serializer.data)
elif request.method == 'POST':
data = JSONParser().parse(request)
serializer = MessageSerializer(data=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(self, request):
if request.user.is_authenticated:
context = self.getContext()
current_user = request.user
if request.POST.get('click', True):
data = request.data
form = MessagesForm(data)
context.update({'form': form})
data_msg = {
'user': request.user.pk,
'content': data['content']
}
if form.is_valid():
print('vamos bien')
msg = MessageSerializer(data=data_msg)
if msg.is_valid():
msg.save()
else:
print('vamos mal')
return self.get(request)
def message_detail(request, pk):
"""
functions retrieves, updates or deletes a message.
"""
try:
message = Message.objects.get(pk=pk)
except Message.DoesNotExist:
return HttpResponse(status=404)
if request.method == 'GET':
serializer = MessageSerializer(message)
return JSONResponse(serializer.data)
elif request.method == 'PUT':
data = JSONParser().parse(request)
serializer = MessageSerializer(message, data=data)
if serializer.is_valid():
serializer.save()
return JSONResponse(serializer.data)
return JSONResponse(serializer.errors, status=400)
elif request.method == 'DELETE':
message.delete()
return HttpResponse(status=204)
def send(request):
serializer = MessageSerializer(data=request.data)
if serializer.is_valid():
serializer.save(user=request.user)
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
