def post(self, request, format=None):
serializer = MessageSerializer(data=request.data)
serializer.is_valid()
message = serializer.data
m = Members
client = m.get_client(message.get('user_id'))
if client:
conversation = client._conv_list.get(message.get('conv_id'))
loop = m.get_loop(message.get('user_id'))
if conversation:
# testできたら移動
text = message.get('message')
image_file = None
segments = ChatMessageSegment.from_str(text)
asyncio.async(
conversation.send_message(segments, image_file=image_file),
loop=loop
).add_done_callback(self._on_message_sent)
return HttpResponse("ok")
# 該当するuser, conv_idがない場合
raise Http404
def receive(self, text_data):
text_data_json = json.loads(text_data)
if text_data_json['method'] == 'ADD_MESSAGE':
text_data_json['user'] = self.user.id # добовляем данные
text_data_json['chat_room'] = self.chat.id
serializer = MessageSerializer(data=text_data_json)
if serializer.is_valid():
print('добовляю сообщение')
serializer.save()
async_to_sync(self.channel_layer.group_send)(
self.room_group_name, {
'data': serializer.data,
'type': 'chat_message',
'method': 'ADD_MESSAGE',
})
if text_data_json['method'] == 'REDACT_MESSAGE':
text_data_json['user'] = self.user.id # добовляем данные
text_data_json['chat_room'] = self.chat.id
message = Message_chat.objects.filter(id=text_data_json['pk'],
user=self.user)
if message.exists() == False:
raise DenyConnection("Нет доступа") # нет доступа
else:
message = message.get()
serializer = MessageSerializer(message, data=text_data_json)
if serializer.is_valid():
serializer.save()
async_to_sync(self.channel_layer.group_send)(
self.room_group_name, {
'data': serializer.data,
'type': 'chat_message',
'method': 'REDACT_MESSAGE',
})
if text_data_json['method'] == 'DELETE_MESSAGE':
message = Message_chat.objects.filter(id=text_data_json['pk'],
user=self.user)
if message.exists() == False:
raise DenyConnection("Нет доступа") # нет доступа
else:
message = message.get()
message.delete()
async_to_sync(self.channel_layer.group_send)(
self.room_group_name, {
'data': {
'id': text_data_json['pk']
},
'type': 'chat_message',
'method': 'DELETE_MESSAGE',
})
def publish(self, request, data, *args, **kwargs):
if "user" in request.channel_session:
band_id = kwargs.get("band_id")
serializer = MessageSerializer(data=data)
serializer.is_valid(raise_exception=True)
serializer.save(
author=User.objects.get(pk=request.channel_session["user"]), band=Band.objects.get(pk=band_id)
)
group = Group(self.CHAT_GROUP_TEMPLATE % band_id)
self.route_send(group, serializer.data)
else:
raise PermissionDenied
def add_message(request):
phone_number = request.POST.get("phone_number", "")
if not check_token(request.POST.get("token", ""), phone_number):
return Response(data={"detail": "unauthorized"}, status=status.HTTP_401_UNAUTHORIZED)
serializer = MessageSerializer(data=request.data)
if serializer.is_valid():
person = Person.objects.get(phone_number=phone_number)
serializer.save(commit_person_id=phone_number, commit_location=person.location)
return Response(status=status.HTTP_204_NO_CONTENT)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def add_message(request):
phone_number = request.POST.get("phone_number", '')
if not check_token(request.POST.get("token", ""), phone_number):
return Response(data={'detail': 'unauthorized'},
status=status.HTTP_401_UNAUTHORIZED)
serializer = MessageSerializer(data=request.data)
if serializer.is_valid():
person = Person.objects.get(phone_number=phone_number)
serializer.save(commit_person_id=phone_number,
commit_location=person.location)
return Response(status=status.HTTP_204_NO_CONTENT)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, **kwargs):
# Check correct arguments provided
if not 'requestedDeviceRegistrationID' in kwargs:
return errors.incorrect_arguments
if not (hasattr(request, "data") & isinstance(request.data, object)):
return errors.incorrect_arguments
if not (("recipient" in request.data) & isinstance(request.data["recipient"], str)):
return errors.incorrect_arguments
if not (("message" in request.data) & isinstance(request.data["message"], str)):
return errors.incorrect_arguments
ownUser = self.request.user
recipientUsername = request.data["recipient"]
try:
messageData = request.data["message"]
except:
return errors.incorrect_arguments
# Check device exists and owned by user
if not hasattr(ownUser, "device"):
return errors.no_device
# Check device ID has not changed
if int(kwargs['requestedDeviceRegistrationID']) != ownUser.device.registrationId:
return errors.device_changed
# Check repipient user exists
try:
recipientUser = User.objects.get(username=recipientUsername)
except:
return errors.no_recipient
# Check recipient device exists
if not hasattr(recipientUser, "device"):
return errors.no_recipient_device
recipientDevice = recipientUser.device
# Check recipient device registrationId matches that sent in message
print(recipientUser.device.registrationId)
print(json.loads(messageData)['registrationId'])
if not (recipientUser.device.registrationId == int(json.loads(messageData)['registrationId'])):
return errors.recipient_identity_changed
serializer = MessageSerializer(data={'content': messageData}, context={'senderDevice': ownUser.device, 'recipientDevice': recipientDevice})
if not serializer.is_valid():
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
else:
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
def post(self, request):
serializer = MessageSerializer(data=request.data)
if serializer.is_valid():
mes = serializer.save()
server = smtplib.SMTP('smtp.gmail.com', 587)
server.ehlo()
server.starttls()
server.ehlo()
server.login(mes.sender, mes.password)
server.sendmail(mes.sender, mes.dest, mes.text)
print(mes.text)
server.quit()
print(serializer.data.get('sender'))
if mes:
return Response(serializer.data,
status=status.HTTP_201_CREATED)
return Response(serializer.errors)
def send_message_view(request):
contacts = request.query_params.get('contacts')
name = request.query_params.get('name')
message = request.query_params.get('message')
if (contacts is None) or (name is None) or (message is None):
return Response({"error": "contacts, name or message are missing."},
status=status.HTTP_400_BAD_REQUEST)
serializer = MessageSerializer(data={
"contacts": contacts,
"name": name,
"message": message
})
if not serializer.is_valid():
return Response({"error": "Incorrect fields."},
status=status.HTTP_400_BAD_REQUEST)
# return Response(None, status=status.HTTP_404_NOT_FOUND)
serializer.save()
return Response(1, status=status.HTTP_201_CREATED)
def post(self, request, format=None):
data = JSONParser().parse(request)
addressees = data.get('addressee', [])
tmp = []
if len(addressees) == 0:
serializer = MessageSerializer(
Message('Email neeeds to have at least one addressee'))
return JsonResponse(serializer.data, safe=False, status=400)
else:
for i, addressee in enumerate(addressees):
serializer = AdresseeSerializer(data=addressee)
if serializer.is_valid():
model = None
try:
model = Adressee.objects.get(
email_address=addressee.get('email_address', None))
except ObjectDoesNotExist:
model = Adressee()
model.email_address = addressee.get('email_address', None)
tmp.append(model)
else:
serializer = MessageSerializer(
Message('Bad json format for addresee at index: ' + i))
return JsonResponse(serializer.data,
safe=False,
status=400)
model = EmailMessage()
model.user = request.user
model.title = data.get('title')
model.created = datetime.utcnow()
model.description = data.get('description')
model.uuid = str(uuid.uuid4())
model.save()
for addressee in tmp:
addressee.message = model
addressee.save()
serializer = EmailSerializer(model)
return JsonResponse(serializer.data, status=201)
def message_list(request):
"""
Return a user's messages, or post a message from one user to another
"""
if request.method == 'GET':
messages = request.user.messages_received
serializer = MessageSerializer(messages, many=True)
return Response(serializer.data)
if request.method == 'POST':
serializer = MessageSerializer(data=request.data)
if serializer.is_valid():
serializer.save(sender=request.user)
message = serializer.data['message']
receiver_id = serializer.data['receiver']
reciever = User.objects.filter(id=receiver_id).first()
sendMessage(message, request.user.phone_number, reciever.phone_number)
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def parse_json(self, json_data: dict):
"""
Convert raw JSON into finished message objects.
:param self: Task instance, supplied by Celery.
:param json_data: Raw JSON.
:return: Parsed data.
"""
messages = list()
bad_messages = list()
data = dict()
users = [dict(t) for t in {tuple(d['author'].items()) for d in json_data}]
total = len(json_data)
progress = WebSocketProgressRecorder(self)
for count, msg in enumerate(json_data):
msg = MessageSerializer(data=msg, context={'users': users})
if msg.is_valid():
messages.append(msg.data)
else:
bad_messages.append((msg.initial_data, msg.errors))
progress.set_progress(count, total)
def sort_chronological(value):
return int(value.get('id') or 0) or value.get('timestamp')
if any([messages[0].get('timestamp'), messages[0].get('id')]):
messages.sort(key=sort_chronological)
data['messages'] = messages
def sort_alphabetical(value):
return value['username']
users.sort(key=sort_alphabetical)
data['users'] = users
progress.set_progress(total, total)
return data
def parse_json(self, json_data: dict):
"""
Convert raw JSON into finished message objects.
:param self: Task instance, supplied by Celery.
:param json_data: Raw JSON.
:return: Parsed data.
"""
messages = []
bad_messages = []
data = {}
_users = {
a['id'] or f'{a["username"]}#{a["discriminator"]}': a
for a in [msg.get('author', unknown_author) for msg in json_data]
}
total = len(json_data)
progress = WebSocketProgressRecorder(self)
for count, msg in enumerate(json_data):
msg = MessageSerializer(data=msg, context={'users': _users})
if msg.is_valid():
messages.append(msg.data)
else:
bad_messages.append((msg.initial_data, msg.errors))
progress.set_progress(count, total)
if any([messages[0].get('timestamp'), messages[0].get('id')]):
messages.sort(key=lambda value: int(value.get('id') or 0) or value.get(
'timestamp'))
data['messages'] = messages
users = list(_users.values())
users.sort(key=lambda value: value['username'])
data['users'] = users
progress.set_progress(total, total)
return data
