def get(self, request, email_code, **kwargs):
try:
email = EmailMessage.objects.get(uuid=email_code)
except ObjectDoesNotExist:
serializer = MessageSerializer(Message('Invalid code'))
return JsonResponse(serializer.data, status=404)
user = email.user
ip_addresses = IpAddress.objects.filter(user=user)
request_ip = request.META.get('REMOTE_ADDR', None)
for ip in ip_addresses:
if ip.ip_address == request_ip:
if self.diff_times_in_seconds(email.created.time(),
datetime.utcnow()) > 4:
email.activated = True
email.save()
print('Activated')
return self.generate_reponse()
return self.generate_reponse()
if email.first_opened is None:
email.first_opened = datetime.utcnow()
email.last_opened = datetime.utcnow()
email.save()
serializer = MessageSerializer(Message('Email readed'))
return self.generate_reponse()
def get(self, request, sender_id, receiver_id):
sender = User.objects.get(pk=sender_id)
receiver = User.objects.get(pk=receiver_id)
parent1 = Message.objects.filter(sender=sender, parent=None)
mails = []
for parent in parent1:
try:
status = Status.objects.get(user=sender, message=parent.id)
if not status.isDeleted:
if parent.receiver == receiver:
mails.append(MessageSerializer(parent).data)
except:
continue
parent2 = Message.objects.filter(sender=receiver, parent=None)
for parent in parent2:
try:
status = Status.objects.get(user=sender, message=parent.id)
if not status.isDeleted:
if parent.receiver == sender:
mails.append(MessageSerializer(parent).data)
except:
continue
mails.sort(key=lambda d: d['timestamp'], reverse=True)
return Response(mails, status=HTTP_200_OK)
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 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 get(self, request, id, **kwargs):
try:
email = EmailMessage.objects.get(pk=id)
if email.activated:
serializer = MessageSerializer(Message('active'))
return JsonResponse(serializer.data, status=200)
else:
serializer = MessageSerializer(Message('not active'))
return JsonResponse(serializer.data, status=200)
except ObjectDoesNotExist:
serializer = MessageSerializer(Message('Invalid email id'))
return JsonResponse(serializer.data, status=404)
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 messages(self, request, *args, **kwargs):
"""
parameters: 'messageID', 'countMessages', 'indent'
"""
messageID = request.GET.get("messageID")
countMessages = request.GET.get("countMessages")
indent = request.GET.get("indent", 0)
for parameter in [messageID, countMessages, indent]:
if parameter == None:
return Response(status=status.HTTP_400_BAD_REQUEST)
dialog = Dialog.objects.get(id=kwargs['pk'])
if len( Message.objects.filter(ownerDialog=dialog, id=messageID) ) == 0:
return Response(status=status.HTTP_404_NOT_FOUND)
if len( DialogOwners.objects.filter(owner=request.user, dialog=Dialog.objects.get( id=kwargs['pk'])) ) == 0:
return Response(status=status.HTTP_403_FORBIDDEN)
queryset = list()
message = Message.objects.get(ownerDialog=dialog, id=messageID)
i = int( countMessages )
indent = int( indent )
check = False
for item in Message.objects.filter(ownerDialog=dialog).order_by('-id'):
if i == 0:
break
if item == message:
check = True
if check and indent != 0:
indent -= 1
continue
if check:
i -= 1
queryset.append(item)
page = self.paginate_queryset(queryset)
kwrg = dict()
kwrg['many'] = True
kwrg['context'] = {
'request': self.request,
'format': self.format_kwarg,
'view': self
}
if page is not None:
serializer = MessageSerializer(page, **kwrg)
return self.get_paginated_response(serializer.data)
serializer = MessageSerializer(queryset, **kwrg)
return Response(serializer.data)
def get(self, request, pk):
try:
replies = Message.objects.filter(
parent__id=pk).order_by("timestamp")
parentMail = Message.objects.get(pk=pk)
serializer = MessageSerializer(replies, many=True)
response_data = {
"parent_mail": MessageSerializer(parentMail).data,
"replies": serializer.data
}
return Response(response_data, status=HTTP_200_OK)
except:
return Response(status=HTTP_400_BAD_REQUEST)
async def receive_json(self, content, **kwargs):
command = content.get('command')
try:
if command == 'join':
await self.channel_layer.group_add(str(content["chat_id"]),
self.channel_name)
if str(content["chat_id"]) not in self.chats:
self.chats.append(content["chat_id"])
elif command == 'channel_message':
channel = Channel.objects.get(id=content['chat_id'])
message = content["message"]
sender = self.scope['user']
message = await database_sync_to_async(channel.add_message
)(message, sender)
data = {
"chat_id": content["chat_id"],
"type": "chat.message",
**MessageSerializer(message).data
}
await self.channel_layer.group_send(str(content["chat_id"]),
data)
elif command == 'private_message':
channel, created = Channel.objects.get_or_create(
name=content['chat_id'], is_private=True)
message = content["message"]
sender = self.scope['user']
members = content['chat_id'].split('__')
members.remove(self.scope['user'].username)
receiver = members[0]
message = await database_sync_to_async(channel.add_message
)(message, sender,
receiver)
data = {
"chat_id": content["chat_id"],
"type": "chat.message",
**MessageSerializer(message).data
}
await self.channel_layer.group_send(
self.scope['user'].username, data)
if self.scope['user'].username != receiver:
await self.channel_layer.group_send(receiver, data)
except Exception as e:
await self.send_json({'error': str(e)})
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 get_employee_workhours(self, employee):
if self.check_if_user_is_employee(employee):
work_days = WorkDay.objects.filter(user=employee)
try:
work_days = self.filter_data(work_days)
work_days.order_by('+finished')
return self.make_paginated_response(work_days)
except Exception as e:
serializer = MessageSerializer(Message('Invalid filters.'))
return JsonResponse(serializer.data, safe=False, status=400)
else:
serializer = MessageSerializer(
Message('Given user must be employee'))
return HttpResponseBadRequest(JSONRenderer().render(
serializer.data))
def send_message(self, request, pk=None):
if 'content' in request.data:
content = request.data['content']
chat = Chat.objects.get(id=pk)
user = request.user
chat_participants = CustomUser.objects.filter(
parties__in=Party.objects.filter(chat=pk))
message = Message.objects.create(user=user,
chat=chat,
content=content)
for participant in chat_participants:
if participant == user:
MessageStatus.objects.create(user=participant,
message=message,
is_read=True)
else:
MessageStatus.objects.create(user=participant,
message=message)
serializer = MessageSerializer(message, many=False)
response = {'message': 'Message sent', 'result': serializer.data}
return Response(response, status=status.HTTP_200_OK)
else:
response = {'message': 'You need to send message'}
return Response(response, status=status.HTTP_400_BAD_REQUEST)
def test_channel_serializer(self):
"""
test return channel
:return:
"""
# Create an instance of a GET request.
creationDate = timezone.now()
self.channel = Channel.objects.create(
identifier="identifier",
name="name",
topic="topic",
first_id_message=0,
last_id_message=0,
server=Server.objects.create(
identifier="identifier_s",
name="name_s",
),
)
self.u = u.objects.create(
identifier="identifier_u",
name="name_u",
)
self.message = Message.objects.create(
identifier="Identifier",
date=creationDate,
user=self.u,
channel=self.channel,
)
self.message.references.set("references")
self.channelSerializer = ChannelSerializer(instance=self.channel)
self.messageSerializer = MessageSerializer(instance=self.message)
self.ServerSerializer = ServerSerializer(instance=self.channel.server)
def get_messages(request):
location = request.GET['location']
start = request.GET['start']
end = request.GET['end']
what = request.GET['what']
kind = request.GET['kind']
all_locations = (location == u'全国')
all_kind = (kind == u'所有')
if all_locations and all_kind:
messages = Message.objects.filter(
what=what).order_by('-created')[int(start):int(end)]
elif not all_locations and all_kind:
messages = Message.objects.filter(
what=what,
commit_location=location).order_by('-created')[int(start):int(end)]
elif not all_locations and not all_kind:
messages = Message.objects.filter(
what=what, commit_location=location,
kind=kind).order_by('-created')[int(start):int(end)]
else:
messages = Message.objects.filter(
what=what, kind=kind).order_by('-created')[int(start):int(end)]
ser = MessageSerializer(messages, many=True)
return Response(ser.data)
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 get(self, request):
if self.has_permission(request.user):
employees = User.objects.filter(groups__name='Employee')
employees = self.filter_data(employees)
return self.make_paginated_response(employees)
else:
serializer = MessageSerializer(Message('Only employers can access this endpoint'))
return JsonResponse(serializer.data, safe=False, status=403)
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 test_get_message(self):
message = Message.objects.create(content='Test')
self.assertEqual(message.views, 0)
response = self.client.get(f'{self.BASE_URL}/messages/{message.id}',
**self.bearer_token)
message.refresh_from_db()
self.assertEqual(response.status_code, HTTP_200_OK)
self.assertEqual(response.json(), MessageSerializer(message).data)
self.assertEqual(message.views, 1)
def get_commited(request):
try:
obj = Person.objects.get(
phone_number=request.GET.get('phone_number', ''))
except Person.DoesNotExist:
return Response(data={'detail': 'person does not exist'},
status=status.HTTP_400_BAD_REQUEST)
msg_ser = MessageSerializer(obj.messages, many=True)
news_ser = NewsSerializer(obj.news, many=True)
return Response({"messages": msg_ser.data, "news": news_ser.data})
def post(self, request):
data = JSONParser().parse(request)
serializer = CodeSerializer(data=data)
if serializer.is_valid():
code = data['code']
code_valid = validate_code(settings.OTP_SECRET, code)
if (code_valid):
new_work_day, work_day = self.start_new_work_day_or_finish_last_one(request.user)
serializer = None
if new_work_day:
serializer = MessageSerializer(Message('New work day started'))
else:
serializer = MessageSerializer(Message('Work day finished'))
return JsonResponse(serializer.data, status=200)
else:
serializer = MessageSerializer(Message('Invalid code'))
return HttpResponseBadRequest(JSONRenderer().render(serializer.data))
else:
return JsonResponse(serializer.errors, safe=False, status=400)
def get(self, request):
ip_address = request.META.get('REMOTE_ADDR', None)
try:
model = IpAddress.objects.get(ip_address=ip_address)
except ObjectDoesNotExist:
model = IpAddress()
model.ip_address = ip_address
model.user = request.user
model.save()
if ip_address is not None:
serializer = MessageSerializer(Message('Machined registered'))
return JsonResponse(serializer.data, status=200)
else:
serializer = MessageSerializer(
Message('Machined could not be registered'))
return JsonResponse(serializer.data, status=500)
serializer = MessageSerializer(Message('Machine already registered'))
return JsonResponse(serializer.data, status=200)
def delete(self, request, email_id, format=None):
email = None
try:
email = EmailMessage.objects.get(pk=email_id)
email.delete()
except ObjectDoesNotExist:
return JsonResponse({"message": 'No email with given id exist'},
status=404)
serializer = MessageSerializer(Message('Email deleted'))
return JsonResponse(serializer.data, status=200)
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
def post(self, request):
message_ids = request.data
if not isinstance(message_ids, list):
return JsonResponse('The request must contain an array of IDs', status.HTTP_400_BAD_REQUEST)
message_queryset = (Message
.objects
.filter(pk__in=message_ids, recipient=request.user.farmer, read_at__isnull=True))
modified_messages_id = list(message_queryset.values_list('id', flat=True))
message_queryset.update(read_at=timezone.now())
response_data = JSONRenderer().render(MessageSerializer(Message.objects.filter(pk__in=modified_messages_id), many=True).data)
return HttpResponse(response_data, content_type="application/json")
def get(self, request, **kwargs):
# if no id then access current user data
employee_id = kwargs.get('employee_id', None)
# Employer can access all users data and employee can only access his own
if not self.has_permission(request.user) and (
employee_id != None and employee_id != request.user.pk):
serializer = MessageSerializer(
Message('Only employers can access this endpoint'))
return JsonResponse(serializer.data, safe=False, status=403)
employee = None
if employee_id != None:
try:
employee = User.objects.get(pk=employee_id)
except ObjectDoesNotExist:
serializer = MessageSerializer(
Message('No employee with given id exists'))
return JsonResponse(serializer.data, safe=False, status=404)
else:
employee = request.user
return self.get_employee_workhours(employee)
def post(self, request):
message = request.data['message']['message']
chat = Chat.objects.filter(id=request.data['id']).first()
message = Message.objects.create(message=message,
emitter=request.user,
chat=chat)
message = MessageSerializer(message)
chat.last_message = message.data['message']
chat.save()
pusher_client.trigger('chat', 'new-message-user',
{"message": message.data})
return Response("Message has been send successfully")
def get(self, request, **kwargs):
user = self.request.user
# Check correct arguments provided
if not 'requestedDeviceRegistrationID' in kwargs:
return errors.incorrect_arguments
# Check device exists and owned by user
if not hasattr(user, "device"):
return errors.no_device
# Check device ID has not changed
if int(kwargs['requestedDeviceRegistrationID']) != user.device.registrationId:
return errors.device_changed
messages = user.device.received_messages.all()
serializer = MessageSerializer(messages, many=True)
return Response(serializer.data, status=status.HTTP_200_OK)
def patch(self, request, email_id, format=None):
data = JSONParser().parse(request)
serializer = EmailSerializer(data=data, partial=True)
email = None
if serializer.is_valid():
try:
email = EmailMessage.objects.get(pk=email_id)
except ObjectDoesNotExist:
serializer = MessageSerializer(
Message('No email with given id exist'))
return JsonResponse(serializer.data, status=404)
email.title = data.get('title', email.title)
email.description = data.get('description', email.description)
email.save()
serializer = EmailSerializer(email)
return JsonResponse(serializer.data, status=201)
else:
return JsonResponse(serializer.errors, safe=False, status=400)
def getMsg(request):
"""
获取消息列表
:param request:
{
"start":0,
"size":6
}
:return:
"""
size = int(request.data.get("size",0))
start = int(request.data.get("start",0)) * size
user = AuthUser.objects.get(username=request.user.username)
msgs = user.receiver.all().order_by('-update_time')[start:start + size]
for msg in msgs:
msg.isDetailed = False
serializer = MessageSerializer(msgs, many=True)
result = serializer.data
for r in result:
r["status"] = True if r["status"] else False
return Response(result)
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)
