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)