def post(self, request, *args, **kwargs): form = MessageForm( request.POST ) if form.is_valid(): data = form.cleaned_data users_t = data["users"].split(",") message = Message( author = request.user, text = data["text"], title = data["title"], date = datetime.now() ) message.save() message.users.add( request.user ) for user in users_t: user = user.strip() try: if user != request.user.username: message.users.add( User.objects.get( username = user ) ) except User.DoesNotExist as e: print user + " does not exist." message.save() return HttpResponseRedirect("/mailbox/list.html" ) else: data = { "MEDIA_URL" : MEDIA_URL, "user" : request.user, "form" : form } data.update( csrf( request ) ) return render_to_response( self.template_name, data )
def create_message_for_user(user, channel_id, text): """ Create a new message """ uc = UserChannel.objects.get(channel_id=channel_id, user_server__user=user) message = Message(channel_id=channel_id, user_channel=uc, text=text) message.save() return message
def create_message_for_user(user, channel_id, text): """ Create a new message """ uc = UserChannel.objects.get( channel_id=channel_id, user_server__user=user) message = Message(channel_id=channel_id, user_channel=uc, text=text) message.save() return message
def create(self, validated_data): # print('serial, create:') user = self.context['request'].user # print('self.context', self.context) # validated data {'room': 'general', 'body': 'ok'} room = validated_data['room'] msg_body = validated_data['body'] msg = Message(room=room, body=msg_body, user=user) msg.save() return msg
def create_message(sender, channel_id, text, user_channel_id): """ Create a new message """ try: uc = UserChannel.objects.get(channel_id=channel_id, nickname=sender) except UserChannel.DoesNotExist: uc = UserChannel(channel_id=channel_id, nickname=sender) uc.save() message = Message(channel_id=channel_id, user_channel=uc, text=text) message.save() return message
def contacttouser(request): if request.method == 'POST': form = contacttouser_form(request.POST) if form.is_valid(): if form.cleaned_data['send_to_all']: for customer in Customer.objects.all(): msg = Message(sender=Manager.objects.get(pk=10).user, receiver=customer.user, create_time=datetime.datetime.now(), text=form.cleaned_data['text'], seen=False) msg.save() else: if form.cleaned_data['receiver'] != None: customer = Customer.objects.get( pk=form.cleaned_data['receiver']) msg = Message(sender=Manager.objects.get(pk=10).user, receiver=customer.user, create_time=datetime.datetime.now(), text=form.cleaned_data['text'], seen=False) msg.save() if form.cleaned_data['receiver'] != None or form.cleaned_data[ 'send_to_all']: return redirect('/manager/') else: form = contacttouser_form() user_information = Customer.objects.all() context = {'user_information': user_information, 'form': form} return render(request, 'manager/contacttouser.html', context)
def post_new_message(request): data = request.POST to_id = data.get('to',0) message = data.get('message',None) try: to_user = User.objects.get(id=to_id) except User.DoesNotExist: to_user = None if to_user and message: message_obj = Message(message=message,msg_from=request.user,msg_to=to_user) message_obj.save() result = {'from_id':message_obj.msg_from.id,'from_name':message_obj.msg_from.username,'message':message_obj.message,'time':str(message_obj.created_on.strftime("%I:%M %p %d, %b %Y"))} return HttpResponse(json.dumps(result),content_type='application/json')
def checkin(request): try: imei = int(request.POST['imei']) mtype = str(request.POST['type']) except: return HttpResponseBadRequest(content=json.dumps({ 'status': 'error', 'reason': 'all of imei, type, latitude and longitude POST options are required' }), content_type='application/json') try: latitude = float(request.POST['latitude']) longitude = float(request.POST['longitude']) except: latitude = None longitude = None if mtype not in ('logon', 'heartbeat', 'low_battery', 'sos', 'tracker'): return HttpResponseBadRequest(content=json.dumps({ 'status': 'error', 'reason': 'allowed values for type: logon, heartbeat, low_battery, sos, tracker' }), content_type='application/json') try: u = Unit.objects.get(imei=imei) except: return HttpResponseNotFound(content=json.dumps({ 'status': 'error', 'reason': 'unit not found' })) MESSAGE_TYPES = { 'logon': 1, 'heartbeat': 2, 'low_battery': 3, 'sos': 4, 'tracker': 5 } m = Message( message_type=MESSAGE_TYPES[mtype], latitude=latitude, longitude=longitude, unit=u ) m.save() return HttpResponse(content=json.dumps({ 'status': 'ok' }), content_type='application/json')
def save_msg(request, to_user, auth_code): authmsg = create_authmsg(request, to_user, auth_code) aeskeyp1, aeskeyp2, cphr_authmsg = cncrypto.aes_encrypt_authcode(authmsg) cphr_aeskeyp1 = cncrypto.rsa_encrypt_aeskey(to_user.pubkey, aeskeyp1) msg = Message() msg.from_org = request.user.get_profile().organization msg.to_user = to_user msg.sysid = str(uuid.uuid4()) msg.enc_msg = cphr_authmsg msg.save() key = Key() key.message = msg key.sysid = str(uuid.uuid4()) key.key = cphr_aeskeyp1 key.min_to_expire = 1 key.save() from_email = "%s <*****@*****.**>" % ( request.user.get_profile().organization.name) subject = "Authorization request" body = """ <a href="secdef://%s/%s">Tap Here</a> to get your authentication code. """ % (msg.sysid, urllib.quote_plus(base64.b64encode(aeskeyp2))) print body email_msg = EmailMessage(subject, body, from_email, [to_user.email]) email_msg.content_subtype = "html" email_msg.send()
def create(self, validated_data): user = self.context['request'].user recipient = get_object_or_404( User, id=validated_data['recipient']['id']) body = '' if 'body' in validated_data: body = validated_data['body'] else: body = None msg = Message(recipient=recipient, body=body, user=user) send_email_on_message_send(msg) msg.save() return msg
def fetch_messages(self, data): messages = Message.last_50_messages() content = { 'command': 'messages', 'messages': self.messages_to_json(messages) } self.send_message(content)
def conversations_list(user: User): dialog_msgs = Message.user_msgs(user) all_conversations = [] used_interlocutors = set() for msg in dialog_msgs: if msg.sender == user: interlocutor = msg.receiver else: interlocutor = msg.sender if interlocutor not in used_interlocutors: all_conversations.append({ "object": interlocutor, "date": msg.date_sent }) used_interlocutors.add(interlocutor) for group in user.inside_group_chats.all(): msg = Message.objects.filter( group_chat_in=group).order_by('-date_sent').first() if msg is None: _date = group.date_created else: _date = msg.date_sent all_conversations.append({"object": group, "date": _date}) all_conversations.sort(key=lambda o: o["date"], reverse=True) return all_conversations
def chat_by_user(request, chat_username): if chat_username == request.user.username: return redirect(reverse('chat_list')) chat_user = get_object_or_404(User, username=chat_username) msg_form = MessageForm(request.POST or None) if msg_form.is_valid(): msg_text = msg_form.cleaned_data['msg_text'] Message.objects.create(receiver=chat_user, sender=request.user, msg_text=msg_text) return redirect(reverse('chat_by_user', args=[chat_username])) cur_user_msgs = Message.user_msgs(request.user) msgs_by_user = cur_user_msgs.filter( Q(sender=chat_user) | Q(receiver=chat_user)).order_by('date_sent') all_conversations = conversations_list(request.user) context = { 'all_conversations': all_conversations, 'msg_form': msg_form, 'new_all_msgs': msgs_by_user, 'chat_user': chat_user, 'chat_username': chat_username, } return render(request, 'core/chat.html', context)
def create_messages(self, convo_obj): """Gets the latest messages from soundcloud and saves them""" messages = self.get_messages(convo_obj.convo_id) for message in messages: message_time = parser.parse(message['sent_at']) if Message.objects.filter(conversation=convo_obj, sent_at=message_time).exists() is not True: message = Message( conversation=convo_obj, user_id=convo_obj.user_id, user_name=convo_obj.user_name, sent_at=message_time, message=message['content'] ) message.save() logger.info('created message: %s', message)
def test_negative_creation(self): with self.assertRaises(TypeError) as error: message = Message(sender=None, receiver=self.kingdom2, message='Test message') self.assertEqual(str(error.exception), 'sender cannot be empty of NULL') with self.assertRaises(TypeError) as error: message = Message(sender={ 'sender': 'ken', 'receiver': 'gap', 'message': 'test' }, receiver=self.kingdom2, message='Test message') self.assertEqual(str(error.exception), 'sender must be of type Kingdom')
def cast_vote(self, name, message_text): """ :param name: kingdom name :param message_text: Create message object and add them to vote ballot """ kingdom = Kingdom.get_kingdom(name) ruler_kingdom = Kingdom.get_kingdom('space') message_obj = Message(ruler_kingdom, kingdom, message_text) self.vote_ballot.append(message_obj)
def __cast_votes(self): # competing_kingdoms will all send messages to other kingdoms for ckingdom_name in self.competing_kingdoms.keys(): for kingdom_name in KINGDOMS.keys(): if kingdom_name != ckingdom_name: sender = Kingdom.get_kingdom(ckingdom_name) receiver = Kingdom.get_kingdom(kingdom_name) message_txt = MessageTable.get_random_message() message_obj = Message(sender, receiver, message_txt) self.vote_ballot.append(message_obj)
def save( self, sender, ): recipients = self.cleaned_data['recipients'] subject = self.cleaned_data['subject'] body = self.cleaned_data['body'] file = self.cleaned_data['file'] message_list = [] for r in recipients: message = Message( subject=subject, body=body, sender=sender, receiver=User.objects.get(username=r), file=file, ) message.save() message_list.append(message) return message_list
def sendmessage(request): cu = auth_session(request) if cu == None: raise response_data = {} response_data['success'] = 0 try: toUser = User.objects.get(sysid=request.POST['uid']) msg = request.POST['msg'] msysid = str(uuid.uuid4()) m = Message(from_user=cu, to_user=toUser, enc_msg=msg, sysid=msysid) m.save() response_data['msgid'] = msysid response_data['success'] = 1 except User.DoesNotExist: pass return render_to_json(response_data)
def test_register_user_already_exists(self, mock_tasks): u = G(User) c = G(Conversation) m = Message( user_name=u.user_name, user_id=u.user_id, conversation=c, message='register', sent_at=datetime.now() ) user, created = self.processor.register_user(m) self.assertFalse(created)
def _gen_messages( row: Series, col_names: List[str], messages: List[Message], importance_coefficient: float = 1.0, polarity: float = 0.0, ) -> None: location = row["location"] location_type = row["location_type"] timestamp_type = row["timestamp_type"] agent = row["agent"] agent_type = row["agent_type"] timestamp = row["timestamp"] if isinstance(timestamp, float): timestamp = str(int(timestamp)) if not timestamp.startswith("202"): return for col_name in col_names: value_type = col_name value = row[col_name] outlierness_col_name = col_name + ":outlierness" outlierness = row.get(outlierness_col_name, None) if not outlierness: outlierness = row.get(col_name + ":grouped_by_time:outlierness", None) if value is None or value == "" or (isinstance(value, float) and isnan(value)): # 'value' is effectively undefined, do not REALLY generate the message. continue fact = Fact( location="[ENTITY:{}:{}]".format(location_type, location), location_type=location_type, value=value, value_type=value_type, timestamp=timestamp, timestamp_type=timestamp_type, agent=agent, agent_type=agent_type, outlierness=outlierness, ) message = Message(facts=fact, importance_coefficient=importance_coefficient, polarity=polarity) messages.append(message)
def new_message(request): """ Display form for message **Context** message form **Template:** :template:`form_new_message.html` """ if request.method == 'POST': space = Space.objects.get(uid=request.POST.get('space')) message = Message(uid=uuid1(), content=request.POST.get('content'), user=request.user, space=space, date=timezone.now()) if request.FILES: message.file = request.FILES['file'] message.save() context = {'result': 'Success', 'uid': str(message.uid), 'content': message.content, 'user': message.user.username, 'date': 'Dzisiaj'} else: context = None return HttpResponse(json.dumps(context), content_type="application/json")
def post_new_message(request): data = request.POST to_id = data.get('to', 0) message = data.get('message', None) try: to_user = User.objects.get(id=to_id) except User.DoesNotExist: to_user = None if to_user and message: message_obj = Message(message=message, msg_from=request.user, msg_to=to_user) message_obj.save() result = { 'from_id': message_obj.msg_from.id, 'from_name': message_obj.msg_from.username, 'message': message_obj.message, 'time': str(message_obj.created_on.strftime("%I:%M %p %d, %b %Y")) } return HttpResponse(json.dumps(result), content_type='application/json')
def _combine(self, registry: Registry, language: str, first: Message, second: Message) -> Message: log.debug("Combining two templates:") log.debug("\t{}".format([c.value for c in first.template.components])) log.debug("\t{}".format([c.value for c in second.template.components])) shared_prefix = self._get_combinable_prefix(first, second) log.debug(f"Shared prefix is {[e.value for e in shared_prefix]}") combined = [c for c in first.template.components] # TODO At the moment everything is considered either positive or negative, which is sometimes weird. # Add neutral sentences. conjunctions = registry.get("conjunctions").get(language, None) if not conjunctions: conjunctions = (defaultdict(lambda x: "NO-CONJUNCTION-DICT"), ) if first.polarity != first.polarity: combined.append( Literal( conjunctions.get("inverse_combiner", "MISSING-INVERSE-CONJUCTION"))) else: combined.append( Literal( conjunctions.get("default_combiner", "MISSING-DEFAULT-CONJUCTION"))) combined.extend(second.template.components[len(shared_prefix):]) log.debug("Combined thing is {}".format([c.value for c in combined])) new_message = Message( facts=first.facts + [fact for fact in second.facts if fact not in first.facts], importance_coefficient=first.importance_coefficient, ) new_message.template = Template(combined) new_message.prevent_aggregation = True return new_message
def send_message(recipient): user = User.query.filter_by(username=recipient).first_or_404() form = MessageForm() if form.validate_on_submit(): msg = Message(author=current_user, recipient=user, body=form.message.data) db.session.add(msg) user.add_notification('unread_message_count', user.new_messages()) db.session.commit() flash(_('Your message has been sent.')) return redirect(url_for('user', username=recipient)) return render_template('send_message.html', title=_('Send Message'), form=form, recipient=recipient)
def test_register_response(self, mock_tasks): self.mock_wallet.return_value.get_new_address.return_value = '1' convo = Conversation( convo_id='test', last_message_time=datetime.now() ) convo.save() Message( user_name='bopeep2', user_id='whatev', conversation=convo, message='register', sent_at=datetime.now() ).save() self.processor.process_messages() self.assertEqual(User.objects.get(user_name='bopeep2').deposit_address, '1')
def _create_message(buttons=None, from_user=None, **kwargs): # if chat is not specified - assume inline message inline = not bool(kwargs.get('chat') or kwargs.get('chat_id')) msg_id = ('id' in kwargs and kwargs.pop('id')) or get_id() if not inline: chat_id = kwargs.get('chat_id') or kwargs.get('chat').id msg_id = Message.get_id(chat_id, msg_id) fields = { 'id': msg_id, 'date': timezone.now(), 'from_user': from_user or create_user(), 'inline_message_id': msg_id if inline else None, **kwargs, } msg = Message.objects.create(**fields) if buttons: msg.set_buttons(buttons) return msg
def webapp_new_message(request, uuid): template = loader.get_template('annonce.html') context = {} conversation = Conversation.objects.get(pk=uuid) query = request.POST['q'] or None if query is not None: Message(conversation=conversation, transmitter=request.user, receiver=request.user, content=query).save() messages = Message.objects.filter(conversation=conversation) ad = Ad.objects.get(conversation=conversation) context.update({ 'conversation': conversation, 'messages': messages, 'ad': ad }) return HttpResponse(template.render(context, request))
def test_kingdom_result(self): """ Unit test case for kingdom_result method. Used in Problem1 """ voting_machine = VotingMachine() vote_ballot = [] all_kingdoms = ['land', 'air', 'ice'] competing_kingdoms = {'space': []} for name in all_kingdoms: sender = Kingdom.get_kingdom('space') receiver = Kingdom.get_kingdom(name) message_txt = 'oaaawaalaa1d22n333a4444pzmzmzmzaztzozh' message_obj = Message(sender, receiver, message_txt) vote_ballot.append(message_obj) voting_machine.execute(vote_ballot, competing_kingdoms) ruler, allies = voting_machine.kingdom_result('space', 2) self.assertEqual(ruler, 'Space') self.assertEqual(allies, 'Land, Air, Ice')
def send_message(request): getUser = getUserFromToken(request) me = UserProfile.objects.get(user_id=getUser.id) msg = Message(sender=me, receiver=getUser, text=request.POST.get("text")) msg.save()
def _gen_messages( self, row: Series, col_names: List[str], messages: List[Message], importance_coefficient: float = 1.0, polarity: float = 0.0, ) -> None: location = row["location"] location_type = row["location_type"] timestamp_type = row["timestamp_type"] agent = row["agent"] agent_type = row["agent_type"] timestamp = row["timestamp"] if isinstance(timestamp, float): timestamp = str(int(timestamp)) # Retain this + last years' monthly stuff. Skip older monthly stuff. if timestamp_type == "month": year, month = timestamp.split("M") if int(year) < datetime.now().year - 1: return # For yearly stuff, keep the last three years. elif timestamp_type == "year": if int(timestamp) < datetime.now().year - 3: return for col_name in col_names: value_type = col_name value = row[col_name] outlierness_col_name = col_name + ":outlierness" outlierness = row.get(outlierness_col_name, None) # There are potentially multiple outlierness values to choose from, corresponding to multiple ways of # grouping the data. TODO: Smarter way to select which on the use if not outlierness: outlierness = row.get( col_name + ":grouped_by_time:outlierness", None) if value is None or value == "" or (isinstance(value, float) and isnan(value)): # 'value' is effectively undefined, do not REALLY generate the message. continue fact = Fact( location="[ENTITY:{}:{}]".format(location_type, location), location_type=location_type, value=value, value_type=value_type, timestamp=timestamp, timestamp_type=timestamp_type, agent=agent, agent_type=agent_type, outlierness=outlierness, ) message = Message(facts=fact, importance_coefficient=importance_coefficient, polarity=polarity) messages.append(message)
def _actions_handler(self, actions): logger.debug('receive actions to handle {}'.format(actions)) for action in actions: logger.debug('actions handle with type {}'.format(action.type)) if action.type == ScenarioActionType.SEND_MESSAGE.name: if self.bot_chat.language == 'ru': if action.parameters.ru_message_text: ru_message = Message('', action.parameters.ru_message_text) send_message(self.chat_id, ru_message) elif self.bot_chat.language == 'en': if action.parameters.en_message_text: en_message = Message('', action.parameters.en_message_text) send_message(self.chat_id, en_message) elif self.bot_chat.language == 'uz': if action.parameters.uz_message_text: uz_message = Message('', action.parameters.uz_message_text) send_message(self.chat_id, uz_message) elif action.type == ScenarioActionType.SEND_FILE: pass elif action.type == ScenarioActionType.SEND_BUTTONS.name: btns = [] for button in action.parameters.buttons: if self.bot_chat.language == 'ru': if button.ru_message_text: btns.append([ Button(button.id, button.ru_message_text[0]).__dict__ ]) elif self.bot_chat.language == 'en': if button.en_message_text: btns.append([ Button(button.id, button.en_message_text[0]).__dict__ ]) elif self.bot_chat.language == 'uz': if button.uz_message_text: btns.append([ Button(button.id, button.uz_message_text[0]).__dict__ ]) if len(btns) > 0: keyboard = Keyboard('keyboard', btns) send_message(self.chat_id, keyboard) elif action.type == ScenarioActionType.REDIRECT_TO_QUEUE.name: redirect_chat(self.bot_chat.language, action.parameters.queue_name, self.chat_id) elif action.type == ScenarioActionType.CLOSE_CHAT.name: close_chat(self.chat_id) elif action.type == ScenarioActionType.SEND_REQUEST_TO_ANOTHER_SERVICE.name: pass elif action.type == ScenarioActionType.CONDITION_CHECK.name: condition_id = action.parameters.condition_check_param.condition_id success_check_step_id = action.parameters.condition_check_param.success_check_step_id fail_check_step_id = action.parameters.condition_check_param.fail_check_step_id condition_check = self.get_condition_by_id(condition_id) steps = self._get_state_by_id( self.bot_chat.bot_scenario_state_id).steps if condition_check(): logger.debug('success check step with step_id {}'.format( success_check_step_id)) self._steps_handler(steps=steps, step_id=success_check_step_id) else: logger.debug('fail check step with step_id {}'.format( fail_check_step_id)) self._steps_handler(steps=steps, step_id=fail_check_step_id) elif action.type == ScenarioActionType.BUTTON_CHECK.name: if self.bot_chat.keyboard_response_button_id: target_state = self._get_state_by_button_id( self.bot_chat.keyboard_response_button_id) if target_state: target_state_id = target_state.state_id self.bot_chat.bot_scenario_target_state_id = target_state_id self.bot_chat.save() self.transmit() elif action.type == ScenarioActionType.SEND_FILE_TO_CLIENT.name: file = FileMessage('file_operator', action.parameters.file.__dict__) send_message(self.chat_id, file)
def test_split_umid(self): assert Message.split_id('a_b') == ['a', 'b']
def test_get_id(self): assert Message.get_id('a', 'b', 'c') == 'c' assert Message.get_id('a', 'b') == 'a_b' assert Message.get_id('a', 'b_c') == 'b_c' assert Message.get_id('a', None) == 'a'