def post(self, request, format=None, **kwargs):
"""
This method checks whether the request is coming
from the User or Admin and saves
Message
"""
error_checks = check_for_private_message_error(request)
if error_checks:
return Response(error_checks,
status=status.HTTP_412_PRECONDITION_FAILED)
message_data = request.data
serializer = MessageSerializer(data=message_data)
if serializer.is_valid():
message = serializer.save()
serializer = MessageViewSerializer(message)
return Response({
"message": serializer.data,
"success": True
},
status=status.HTTP_201_CREATED)
else:
logging.info(serializer.errors)
return Response(status=status.HTTP_400_BAD_REQUEST)
def post(self, request, format=None):
serializer = MessageSerializer(data=request.DATA,
context={'request': request})
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
else:
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def message_list(request):
if request.method == 'GET':
ms = Message.objects.all()
serializer = MessageSerializer(ms, many=True)
return Response(serializer.data,status=status.HTTP_200_OK)
elif request.method == 'POST' or request.method == 'PUT':
serializer = MessageSerializer(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 get(self, request, format=None):
# serialized_messages = MessageSerializer(Acquaintance.objects.all().order_by("-updated_at").first(), request.user, many = False)
serialized_messages = MessageSerializer(
Acquaintance.objects.all().order_by("-updated_at"),
request.user,
many=True)
return Response(serialized_messages.data)
def post(self, request):
user = request.user
message_id = int(unicode(request.data.get('message_id', 0)))
m_id = int(message_id)
try:
message = Message.objects.get(id=m_id)
message.is_seen = True
message.save()
messages = Message.objects.filter(receiver=user, is_seen=False)
total_unseen = len(messages)
message_read.send(sender=message.sender,
receiver=user,
message=message,
kwargs=None)
serializer = MessageSerializer(message, many=False)
return {"messages": serializer.data, "total_unseen": total_unseen}
except Exception, R:
log = Logger(log=str(R))
log.save()
return {'messages': {'message': 'error ' + str(R)}}
def get(self, request, pk, format=None):
message = self.get_object(pk)
if request.user == message.user:
serializer = MessageSerializer(message)
return Response(serializer.data)
else:
return Response(status=status.HTTP_400_BAD_REQUEST)
def get(self, request, format=None):
self.get_query_params()
self.verify_user()
self.verify_classgroup()
queryset = Message.objects.all()
if "in_reply_to_id" not in self.query_dict:
queryset = queryset.filter(reply_to__isnull=True)
queryset = self.filter_query_params(queryset).order_by("-modified")
paginator = Paginator(queryset, RESULTS_PER_PAGE)
page = request.QUERY_PARAMS.get("page")
try:
serializer = PaginatedMessageSerializer(
paginator.page(page), context={'request': request})
add_likes_to_data(serializer.data['results'], request.user)
except PageNotAnInteger:
serializer = MessageSerializer(queryset,
context={'request': request},
many=True)
add_likes_to_data(serializer.data, request.user)
except EmptyPage:
serializer = PaginatedMessageSerializer(
paginator.page(paginator.num_pages),
context={'request': request})
add_likes_to_data(serializer.data['results'], request.user)
return Response(serializer.data)
def post(self, request):
try:
message_id = int(unicode(request.data['message_id']))
log = Logger(log="MESSAGE ID IN POST IS %d" % message_id)
log.save()
mode = int(unicode(request.data.get('mode', 0)))
log = Logger(log="MODE IN POST IS %d" % mode)
log.save()
message = Message.objects.get(id=message_id)
message.delete()
if mode == 1:
messages_list = Message.objects.filter(
sender_id=request.user.id)
else:
messages_list = Message.objects.filter(
receiver_id=request.user.id)
serializer = MessageSerializer(messages_list, many=True)
return {'messages': serializer.data}
except Exception as e:
log = Logger(
log="SOMETHING BAD HAS HAPPENED IN DELETE POST %s %d" %
(e, message_id))
log.save()
return {
'messages': 'error',
'exception': 'message id is a mandatory'
}
def get(self, request, username, friend, format=None):
# print username, friend
room = self.get_chatroom(username, friend).room
# print room
messages = reversed(room.messages.order_by('-timestamp')[:50])
# print messages
serializer = MessageSerializer(messages, many=True, context={'request': request})
return Response(serializer.data)
def snippet_detail(request, pk):
"""
Retrieve, update or delete a message instance.
"""
try:
snippet = Message.objects.get(pk=pk)
except Message.DoesNotExist:
return Response(status=status.HTTP_404_NOT_FOUND)
if request.method == 'GET':
add_log('retrieve msg with id=%s' % (str(pk)))
serializer = MessageSerializer(snippet)
return Response(serializer.data)
elif request.method == 'PUT':
serializer = MessageSerializer(snippet, data=request.data)
if serializer.is_valid():
serializer.save()
add_log('put msg with id=%s' % (str(pk)))
return Response(serializer.data)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
elif request.method == 'DELETE':
snippet.delete()
add_log('delete msg with id=%s' % (str(pk)))
return Response(status=status.HTTP_204_NO_CONTENT)
def outgoing_messages_view(request):
"""
A view that returns outgoing messages
"""
try:
data = JSONParser().parse(request)
user_id = data['sender_id'].encode('utf-8')
messages_list = Message.objects.filter(sender_id=user_id)
serializer = MessageSerializer(messages_list, many=True)
except Exception as e:
return Response({})
return Response(serializer.data)
def send_question_view(request):
email = str(request.data.get('email', ''))
full_name = str(request.data.get('full_name', ''))
message = request.data['message']
subject = request.data['subject']
try:
serializer = MessageSerializer(message, many=False)
return Response(serializer.data)
except Exception as e:
return None
def get(self, request, format=None):
global condition_url, planner_url
city_id = self.request.query_params.get('cityId', None)
if city_id is not None:
city_data = City.objects.filter(id=city_id)
if city_data is not None:
message = getMessage(city_data)
serializer = MessageSerializer(message)
return Response(serializer.data, status=status.HTTP_200_OK)
else:
return_data = {}
return_data['cityId'] = ["cityId is required"]
return Response(return_data, status=status.HTTP_400_BAD_REQUEST)
def incoming_messages_view(request):
"""
A view that returns incoming messages
"""
try:
data = JSONParser().parse(request)
user_id = data['receiver_id'].encode('utf-8')
messages_list = Message.objects.filter(receiver_id=user_id)
serializer = MessageSerializer(messages_list, many=True)
except Exception as e:
log = Logger(log='WE F****D IT UP {}'.format(str(e)))
log.save()
return {}
return Response(serializer.data)
def getMessagesByUsername(self, request):
response = {'status': 'FAILED'}
searchString = request.GET.get('username')
if searchString:
# Query messages for any username starting with
# query param username
querySet = Message.objects.filter(
username__startswith=searchString)
queryData = MessageSerializer(querySet, many=True).data
# creating response object
response['status'] = "SUCCESS"
response['messages'] = queryData
return JsonResponse(response)
def get(self, request):
try:
title = request.params.get('title', '')
body = request.params.get('body', '')
receiver_id = int(unicode(request.params.get('receiver_id')))
receiver = User.objects.get(id=receiver_id)
sender = request.user
#return {"receiver":receiver.id,"sender":sender.id}
except Exception as e:
log = Logger(log="WE FAILED LOUDLY" + str(e))
log.save()
return {"message": "error" + str(e)}
try:
message = Message.objects.create(title=title,
body=body,
sender=sender,
receiver=receiver)
messages_list = Message.objects.filter(sender_id=sender.id)
serializer = MessageSerializer(messages_list, many=True)
message_sent.send(sender=sender,
receiver=receiver,
message=message,
kwargs=None)
if receiver.messagingsettings:
if receiver.messagingsettings.duplicate_private:
message_duplicate_to_email.send(sender=sender,
receiver=receiver,
message=message,
kwargs=None)
except Exception as R:
log = Logger(log=str(R))
log.save()
return {'messages': serializer.data}
def message_list(request):
"""
List all messages, or create a new message.
"""
if request.method == 'GET':
snippets = Message.objects.all()
serializer = MessageSerializer(snippets, many=True)
add_log('get all msgs', " list method")
return Response(serializer.data)
elif request.method == 'POST':
serializer = MessageSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
add_log('new post', "user created a new post")
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def get(self):
try:
limit = int(request.args.get('limit', -1))
offset = int(request.args.get('offset', -1))
if limit < 0:
limit = config.DEFAULT_COUNT_MESSAGES
if offset < 0:
offset = 0
except Exception as e:
logger.error(e)
raise APIException('wrong arguments')
messages = ChatMessage.select()\
.where(ChatMessage.chat == None)\
.order_by(-ChatMessage.date_created)\
.offset(offset)\
.limit(limit)
return {
'messages': [MessageSerializer(m).calc() for m in messages],
}
def save_model(self, request, obj, form, change):
obj.save()
m_data = MessageSerializer(obj).data
msg = ['message', [m_data]]
Group('chat_room').send({'text': json.dumps(msg)})
def get(self, request, *args, **kwargs):
messages = Message.objects.get_conversation_between(
from_user=request.user.pk,
to_user=User.objects.filter(pk=request.GET.get('other_user_id')))
serializer = MessageSerializer(messages, many=True)
return Response(serializer.data)
def get(self, request):
messages = Message.objects.filter(recipient=request.user)
return Response(
data=MessageSerializer(messages, many=True).data,
status=st.HTTP_200_OK
)
def post(self):
message = ChatMessage.create(user=request.user, text=self.data['text'])
result = {'message': MessageSerializer(message).calc()}
send_ws(result, WS_CHAT_MESSAGE)
return result
def post(self, request, *args, **kwargs):
try:
log = Logger(log='We will try to send %s' % str(request.data))
log.save()
title = request.data.get('title', 'default title')
body = request.data.get('body', 'default body')
try:
sender_id = int(unicode(request.data.get('sender_id')))
sender = User.objects.get(id=sender_id)
except Exception as e:
sender = request.user
receiver_id = int(unicode(request.data.get('receiver_id')))
log = Logger(log='MESSAGE RECEIVER ID %s' % receiver_id)
log.save()
except Exception as e:
log = Logger(log='So far we failed sending message %s' % str(e))
log.save()
return {"message": "error" + str(e)}
try:
receiver = User.objects.get(id=receiver_id)
log = Logger(log='BYPASSED ONE')
log.save()
#return {"receiver":receiver.id,"sender":sender.id}
except Exception as e:
log = Logger(log="WE FAILED LOUDLY TO READ THE RECEIVER " + str(e))
log.save()
return {'messages': []}
try:
message = Message.objects.create(title=title,
body=body,
sender=sender,
receiver=receiver)
messages_list = Message.objects.filter(sender_id=sender.id)
serializer = MessageSerializer(messages_list, many=True)
message_sent.send(sender=sender,
receiver=receiver,
message=message,
kwargs=None)
if receiver.messagingsettings:
if receiver.messagingsettings.duplicate_private:
message_duplicate_to_email.send(sender=sender,
receiver=receiver,
message=message,
kwargs=None)
except Exception as e:
log = Logger(log="We were unable to send message - " + str(e))
log.save()
return {'messages': []}
return {'messages': serializer.data}