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 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 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 get(self, request, pk):
message = get_object_or_404(Message, pk=pk, sender_id=request.user.id)
if not message.message_read:
message.message_read = True
message.save()
serializer = MessageSerializer(message)
return Response(serializer.data, status=status.HTTP_200_OK)
def populate(self, qs):
for room in qs:
ser = LobbySerializer(room)
data = ser.data
newest = MessageSerializer(room.message_set.order_by('-created')[0:5], many=True)
data['newest'] = newest.data
yield data
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 send_to_group(request):
try:
group_id = request.data.get('group_id')
group = Group.objects.get(id=group_id)
message = Message.objects.create(text=request.data.get('text'), owner=request.user,
time=now())
for member in group.members.all():
message.receiver.add(member)
send_push_notification('YOUR_TITLE', MessageSerializer(message).data,
device=member.user_device, store=False)
message.save()
serializer = MessageSerializer(message)
return Response(serializer.data, status=status.HTTP_201_CREATED)
except:
return Response(status=status.HTTP_400_BAD_REQUEST)
def messages(request, room_id):
room = get_object_or_404(Room, id=room_id)
messages = room.messages.order_by('-id')[:200]
messages = reversed(messages)
data = MessageSerializer(messages, many=True).data
return Response(data=data, status=status.HTTP_200_OK)
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 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_lists(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)).last()
serializer = MessageSerializer(messages,context={'request': request})
return JsonResponse(serializer.data,safe=False)
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 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 messages_list(self, request, *args):
thread_id = request.query_params.get('threadId')
messages = Message.objects.filter(
thread_id=thread_id).order_by('-date_send')
serializer = MessageSerializer(messages, many=True)
paginator = PageNumberPagination()
paginator.page_size = 20
data = paginator.paginate_queryset(serializer.data, request)
return paginator.get_paginated_response(data=data)
def chat_message(message):
user = message.channel_session['user']
user_obj = User.objects.get(username=user)
chat_id = message.channel_session['chatid']
message_body = message.content['text']
chat_obj = Chat.objects.get(pk=chat_id, users=user_obj)
msg = chat_obj.add_message(user_from=user_obj, message_body=message_body)
msg_return = MessageSerializer(msg)
Group("chat_" + chat_id).send({"text": json.dumps(msg_return.data)})
async def receive(self, text_data):
text_data_json = json.loads(text_data)
text = text_data_json['message']
message = Message(text=text, room_name=self.scope['url_route']['kwargs']['room_name'])
message.save()
await self.channel_layer.group_send(self.room_group_name,
{'type': 'chat_message',
'message': MessageSerializer(message).data})
def message_history(request):
date = request.GET.get('date', '')
try:
messages = Message.objects.message_history(date)
except ValidationError:
return Response(status=status.HTTP_400_BAD_REQUEST)
serializer = MessageSerializer(messages, many=True)
return Response(serializer.data)
def show_conversation(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)
serializer = MessageSerializer(messages, many=True)
return Response(serializer.data)
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)
async def receive_json(self, content, **kwargs):
message = await self.save_message(content)
payload = MessageSerializer(message).data
await self.channel_layer.group_send(
self.group_name,
{
'type': 'chat.message',
'payload': payload
}
)
def edit_message(request):
try:
message_id = request.data.get('message_id')
message = Message.objects.get(id=message_id)
new_text = request.data.get('new_text')
message.text = new_text
message.save()
serializer = MessageSerializer(message)
return Response(serializer.data, status=status.HTTP_200_OK)
except:
return Response(status=status.HTTP_400_BAD_REQUEST)
def messages(self, request, pk=None):
"""
Returns messages of specified by id chat
:param request:
:param pk:
:return:
"""
try:
chat = self.get_object()
except Chat.DoesNotExist:
return Response(status=status.HTTP_404_NOT_FOUND)
queryset = chat.messages.select_related('chat',
'user').prefetch_related(
'images', 'user__images')
page = self.paginate_queryset(queryset)
if page is not None and request.GET.get('page') is not None:
return self.get_paginated_response(
MessageSerializer(page, many=True).data)
return Response(MessageSerializer(queryset, many=True).data)
def get_rooms(self):
return [{
'name': model.name,
'display_name': model.display_name,
'image': model.image.url,
'last_message': MessageSerializer(Message.objects.filter(room=model.id).last()).data,
'participants': [
{'name': x[0], 'public_key': x[1]}
for x in model.participants.values_list('name', 'public_key')
],
'admin': model.admin.name == self.user.name
} for model in Room.objects.filter(participants__name=self.user.name).all()]
def chat_room(request, label):
"""Vista Sala de chat."""
# If the room with the given label doesn't exist, automatically create it
# upon first visit (a la etherpad).
room, created = Room.objects.get_or_create(label=label)
# We want to show the last 50 messages, ordered most-recent-last
messages = reversed(room.messages.order_by('-timestamp')[:50])
serializer = MessageSerializer(messages, many=True)
# import pdb; pdb.set_trace()
return Response(serializer.data)
def retrieve(self, request, pk):
'''Get all messages from the specified chat'''
profile = Profile.objects.get(user=request.user)
chat = Chat.objects.get(id=pk)
if is_chat_available(profile, chat):
messages = Message.objects.filter(chat_id=pk).order_by('-date')
serializer = MessageSerializer(messages, many=True)
return Response(serializer.data, status=status.HTTP_200_OK)
message = {
'detail': 'user can\'t get messages from a chat he is not in'
}
return Response(message, status=status.HTTP_400_BAD_REQUEST)
def message(request):
if request.user.is_authenticated:
data = request.POST
MessageSerializer.sender = request.user.id
MessageSerializer.receiver = request.POST['receiver']
MessageSerializer.text = request.POST['text']
serializer = MessageSerializer(data=data)
m = serializer
print(m)
s = m.is_valid()
if s:
m.save()
return JsonResponse({'message': 'message saved'}, status=201)
else:
return JsonResponse({'message': 'invalid message'}, status=400)
else:
return JsonResponse({'message': 'You are not login'}, status=401)
# def conversation(request):
# if request.user.is_authenticated:
# def edit(request):
# if request.user.is_authenticated:
# data = request.POST
# s = UserSerializer(data=data)
# print(f'======>{s}')
# u = s.is_valid()
# if u:
# s.update(request.user.username,request.POST['username'])
# return JsonResponse(
# {
# 'message' : 'profile edited!'
# },status=201
# )
# else:
# return JsonResponse(
# {
# 'message' : 'wrong request'
# }
# )
# else:
# return JsonResponse(
# {
# 'message' : 'you are not login!'
# },status=401
# )
# def creat_group(request):
# if request.user.is_authenticated:
def get(self, *args, **kwargs):
page_number = kwargs['page_number']
page_size = settings.PAGINATION_PAGE_SIZE
messages = Message.objects.all()[page_number *
page_size:(page_number + 1) *
page_size]
return Response(
data=MessageSerializer(messages, many=True).data,
status=HTTP_200_OK,
)
def list_messages(request, flat_id=None):
try:
flat = Flat.objects.get(id=flat_id)
except ObjectDoesNotExist:
return Response(
data={'message': 'The flat {0} does not exist.'.format(flat_id)},
status=400)
messages = Message.objects.filter(flat=flat)
return Response(data={
'messages': MessageSerializer(messages, many=True).data,
},
status=200)
def test_view_existing_message(self):
self.message = {'id': 1, 'text': "Hot and sunny day", 'topic': self.topics_saved[0]}
self.message_saved = Message.objects.create(**self.message)
factory = APIRequestFactory()
message_view = MessageViewSet.as_view({'get': 'retrieve'})
request = factory.get(reverse('messages-detail', args=(1,)))
response = message_view(request, pk=1)
response.render()
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(json.loads(response.content), MessageSerializer(self.message_saved).data)
self.assertEqual(response['content-type'], 'application/json')
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)
