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)