def METHOD_NAME(self, request, format=None):
    """
    Adds one new message to the chatroom.
    """
    serializer = self.serializer_class(data=request.data)
    # Return bad request if serializer is not valid
    if not serializer.is_valid():
        context = {"bad_request": "Invalid serializer"}
        return Response(context, status=status.HTTP_400_BAD_REQUEST)
    order_id = serializer.data.get("order_id")
    if order_id is None:
        return Response(
            {"bad_request": "Order ID does not exist"},
            status.HTTP_400_BAD_REQUEST,
        )
    order = Order.objects.get(id=order_id)
    if not (request.user == order.maker or request.user == order.taker):
        return Response(
            {"bad_request": "You are not participant in this order"},
            status.HTTP_400_BAD_REQUEST,
        )
    if order.status not in [Order.Status.CHA, Order.Status.FSE]:
        return Response(
            {"bad_request": "Order is not in chat status"},
            status.HTTP_400_BAD_REQUEST,
        )
    if order.maker == request.user:
        sender = order.maker
        receiver = order.taker
    elif order.taker == request.user:
        sender = order.taker
        receiver = order.maker
    chatroom, _ = ChatRoom.objects.get_or_create(
        id=order_id,
        order=order,
        room_group_name=f"chat_order_{order_id}",
        defaults={
            "maker": order.maker,
            "maker_connected": order.maker == request.user,
            "taker": order.taker,
            "taker_connected": order.taker == request.user,
        },
    )
    last_index = Message.objects.filter(order=order, chatroom=chatroom).count()
    new_message = Message.objects.create(
        index=last_index + 1,
        PGP_message=serializer.data.get("PGP_message"),
        order=order,
        chatroom=chatroom,
        sender=sender,
        receiver=receiver,
    )
    # send Telegram notification for new message (if conditions apply)
    send_notification.delay(
        chat_message_id=new_message.id, message="new_chat_message"
    )
    # Send websocket message
    if chatroom.maker == request.user:
        peer_connected = chatroom.taker_connected
    elif chatroom.taker == request.user:
        peer_connected = chatroom.maker_connected
    channel_layer = get_channel_layer()
    async_to_sync(channel_layer.group_send)(
        f"chat_order_{order_id}",
        {
            "type": "PGP_message",
            "index": new_message.index,
            "message": new_message.PGP_message,
            "time": str(new_message.created_at),
            "nick": new_message.sender.username,
            "peer_connected": peer_connected,
        },
    )
    # if offset is given, reply with messages
    offset = serializer.data.get("offset", None)
    if offset or offset == 0:
        queryset = Message.objects.filter(order=order, index__gt=offset)
        messages = []
        for message in queryset:
            d = ChatSerializer(message).data
            # Re-serialize so the response is identical to the consumer message
            data = {
                "index": d["index"],
                "time": d["created_at"],
                "message": d["PGP_message"],
                "nick": User.objects.get(id=d["sender"]).username,
            }
            messages.append(data)
        response = {"peer_connected": peer_connected, "messages": messages}
    else:
        response = {}
    return Response(response, status.HTTP_200_OK)