def message(request): try: username = request.session['user'] except KeyError: request.agent.queue.put(SMAPResponse('error', reason='not_logged_in')) return try: channel_name = request['channel'] content = request['content'] except KeyError: request.agent.queue.put(SMAPResponse('error', reason='params_invalid')) return with request.db.transaction(): user = User.get(User.username == username) try: channel = Channel.get(Channel.name == channel_name) except Channel.DoesNotExist: request.agent.queue.put(SMAPResponse('error', reason='invalid_channel')) return if channel.contains_user(user): Message.create(user=user, channel=channel, content=content) for u in channel.users: request.agent.dispatch(u.username, SMAPResponse('message', channel=channel.name, username=username, content=content)) else: request.agent.queue.put(SMAPResponse('error', reason='not_joined_yet'))
def test_tune_last_seen_message(self): channel = self.channel tune_manager = TuneManager.get() Thread.objects.add_member(self.mehdi, channel) listening_date = timezone.now() tune_manager.tune(self.adam, channel, listening_date) first_message = channel.send(Message(contents="Hey"), self.adam) memb = Membership.objects.get_membership(self.adam, channel) self.assertTrue(Membership.objects.has_seen_message(self.adam, first_message)) self.assertFalse(Membership.objects.has_seen_message(self.mehdi, first_message)) self.assertTrue(Membership.objects.has_seen_thread(self.adam, channel)) self.assertFalse(Membership.objects.has_seen_thread(self.mehdi, channel)) time.sleep(LISTENING_RENEWAL_RATE) second_message = channel.send(Message(contents="Hey :)"), self.mehdi) self.assertFalse(Membership.objects.has_seen_message(self.adam, second_message)) self.assertFalse(Membership.objects.has_seen_message(self.mehdi, second_message)) self.assertFalse(Membership.objects.has_seen_thread(self.adam, channel)) self.assertFalse(Membership.objects.has_seen_thread(self.mehdi, channel))
def mail_results(self): for faction in Faction.objects.all(): actions = Action.objects.filter(faction=faction, turn=self.turn) Message.mail_line( faction.controller, "%s Turn Results: %s" % (faction.name, self.display_turn()), "\n".join([a.p_str for a in actions]))
def send_message_to_group(request): id = request.POST.get('group_id') group = Group.objects.get(id=id) message = Message(text=request.POST.get("message", ""), sender=request.user, recipient=group) message.save() return HttpResponse()
def manager_new_message_view(request): if request.method == 'GET': print('form method get') form = NewMessageForm return render(request, 'messaging/manager_write.html', { 'form': form }) elif request.method == 'POST': usern = request.user.site_user form = NewMessageForm(request.POST) if form.is_valid(): text = form.cleaned_data['text'] receiver = form.cleaned_data['receiver'] header = form.cleaned_data['header'] message = Message(text=text, receiver=receiver, header=header, sender=usern) message.save() else: return HttpResponse(form.errors) return redirect(reverse('manager_message_box'))
def save(self, sender, parent_msg=None): recipients = self.cleaned_data['recipient'] subject = self.cleaned_data['subject'] body = self.cleaned_data['body'] record = self.cleaned_data['record'] message_list = [] for r in recipients: msg = Message( sender = sender, recipient = r, subject = subject, body = body, record = record, ) if parent_msg is not None: msg.parent_msg = parent_msg parent_msg.replied_at = datetime.datetime.now() parent_msg.save() msg.save() message_list.append(msg) if notification: if parent_msg is not None: notification.send([sender], "messages_replied", {'message': msg,}) notification.send([r], "messages_reply_received", {'message': msg,}) else: notification.send([sender], "messages_sent", {'message': msg,}) notification.send([r], "messages_received", {'message': msg,}) return message_list
def send_message_to_user(request): user_id = request.POST.get("user_id") message_text = request.POST.get("message") user = User.objects.get(id=user_id) message = Message(text=message_text, sender=request.user, recipient=user.profile) message.save() return HttpResponse()
def show_line(request, line_id, template="lines/show_line.html"): gtu = None if not request.user.is_superuser: gtu = get_object_or_404(Character, user=request.user) name = gtu.name else: name = "The GMs" line = get_object_or_404(Line, id=line_id) line_controls = [] try: line_controls += ['The mailbox %s (code %s)' % (line.mailbox.name, line.mailbox.code)] except: pass try: line_controls += ['The territory control faction %s' % Faction.objects.get(controller=line).name] except Faction.DoesNotExist: pass for s in SecureLocation.objects.filter(controller=line): line_controls += ['The secure location %s' % s] promote = request.GET.get('promote', None) if promote: promoted_user = get_object_or_404(User, id=int(promote)) from_membership = get_object_or_404(LineOrder, line=line, character__user=promoted_user) print from_membership.character, from_membership.order to_membership = get_object_or_404(LineOrder, line=line, order=from_membership.order - 1) print to_membership.character, to_membership.order # get around db column uniqueness enforcement neworder = to_membership.order from_membership.order = 999 from_membership.save() to_membership.order += 1 to_membership.save() from_membership.order = neworder from_membership.save() while not LineOrder.objects.filter(line=line, order=1).exists(): for o in LineOrder.objects.filter(line=line).order_by('-order'): o.order -= 1 o.save() Message.mail_to(from_membership.character, "Promotion Alert", "%s promoted you in the %s line! Your new rank is %s. %s" % (name, line.name, from_membership.order, "You are now in charge." if from_membership.order == 1 else ""), sender="Group Command") Message.mail_to(to_membership.character, "Demotion Alert", "%s demoted you in the %s line. Your new rank is %s." % (name, line.name, to_membership.order), sender="Group Command") return redirect('show_line', line_id) if not request.user.is_superuser: membership = get_object_or_404(LineOrder, character=gtu, line=line) else: membership = None context = { "line": line, "is_leader": line.current_leader().character == gtu, "line_controls": line_controls, "line_members": line.members.all().order_by('lineorder'), "membership": membership, } return render(request, template, context)
def setUp(self): self.user1 = User.objects.create_user('user3', '*****@*****.**', '123456') self.user2 = User.objects.create_user('user4', '*****@*****.**', '123456') self.msg1 = Message(sender=self.user1, recipient=self.user2, subject='Subject Text 1', body='Body Text 1') self.msg2 = Message(sender=self.user1, recipient=self.user2, subject='Subject Text 2', body='Body Text 2') self.msg1.sender_deleted_at = datetime.datetime.now() self.msg2.recipient_deleted_at = datetime.datetime.now() self.msg1.save() self.msg2.save()
def add_message(self, **kwargs): """ Send a message to the player """ m = Message(turn=self.game.current_turn, **kwargs) m.save() m.recipient_set.add(self) return m
def generate_resources(self): for faction in Faction.objects.all(): generated = [] for territory in faction.territory_set.filter(special=MINE): generated.append("%s generates %s" % (territory.name, territory.resource_generated())) try: Message.mail_line(faction.controller, "Resources Generated", "Your territories generated the following resources:\n%s" % "\n".join(generated)) except: pass
def check_and_notify(self): if self.notified == True: return False for s in self.overlaps(): if s.creator.alive: Message.mail_to(s.creator, "Security Alarm: %s" % self.location, "Security alert! Entry window detected; possible breach attempt in progress at %s, start time: %s" % ( self.location, localtime(self.start_time)), sender="Security", urgent=True) self.notified = True self.save() return True
def compose_message_submit(request): conversations = Conversation.objects.all().filter( receiver=request.user).order_by('-lastMessageTime') newMessages = 0 for conversation in conversations: if conversation.is_read == False: newMessages += 1 if request.method == "POST": title = request.POST.get("title") receiver = request.POST.get("receiver") content = request.POST.get("content") facility = request.POST.get("applications") conversation = Conversation() message = Message() conversation.title = title user = User.objects.all().filter(username=receiver)[0] conversation.receiver = user conversation.sender = request.user message.reciever = user message.text = content message.sender = request.user application = CoopApplication.objects.filter( application__user__user=user, facility__title=facility)[0] message.application = application.application conversation.save() message.conversation = conversation message.save() return HttpResponseRedirect("/manager/messages/")
def gm_mail_home(request, template="messaging/mail_home.html"): if not request.user.is_superuser: raise Http404 context = { 'special_mailboxes': Mailbox.objects.filter(public=True, type=0).order_by('name'), 'char_mailboxes': Mailbox.objects.filter(public=True, type=1).order_by('name'), 'group_mailboxes': Mailbox.objects.filter(public=True, type=2).order_by('name'), 'send_mailboxes': Mailbox.objects.all(), 'read_mailboxes': Mailbox.objects.all() } if request.method == 'POST': try: context['mail_text'] = request.POST.get('text') new_mail = Message() new_mail.sender = Mailbox.objects.get(code=request.POST.get('from_code')) try: new_mail.to = Mailbox.objects.get(code=request.POST.get('to_code')) except Mailbox.DoesNotExist: try: new_mail.to = Mailbox.objects.get(name=request.POST.get('to_name')) except Mailbox.DoesNotExist: raise ValidationError("That mailbox doesn't exist.") new_mail.text = request.POST.get('text') new_mail.subject = request.POST.get('subject') print request.POST.get('anon') == 'on' new_mail.anon = request.POST.get('anon') == 'on' new_mail.save() subprocess.Popen(['zwrite', '-d', '-c', 'consortium-sekrit-auto', '-m', "Mail from %s to %s\nSubject: %s\n%s" % (new_mail.sender.name, new_mail.to.name, new_mail.subject, new_mail.text.replace('"', "'"))]) messages.success(request, "Sent mail to %s" % new_mail.to.name) context['mail_text'] = '' except ValidationError, e: messages.error(request, e.messages[0])
def new_message(request): if request.method == 'POST' and request.is_ajax(): text = request.POST['text'] receiver_name = request.POST['receiver_name'] receiver = User.objects.get(username=receiver_name) sender = request.user message = Message(text=text, sender=sender, receiver=receiver) message.save() if message.id is not None: return HttpResponse('Message has been sent') return HttpResponse('Error: Not POST or AJAX')
def check_collisions_and_notify(new_window): query_set = new_window.overlaps() if isinstance(new_window, EntryWindow): for s in query_set: Message.mail_to(s.creator, "Security Window Triggered", "Security alert! Possible breach attempt at %s, time: %s" % (new_window.location, new_window.start_time), sender="Security") elif isinstance(new_window, SecurityWindow): for e in query_set: Message.mail_to(new_window.creator, "Security Window Triggered", "Security alert! Possible breach attempt at %s, time: %s" % (new_window.location, e.start_time), sender="Security") return query_set
def create_public_message(author, thread, content): now = timezone.now() thread.last_message_date = now thread.save() message = Message(author=author, markdown_content=content, timestamp=now, parent_thread=thread) message.save() return message
def mutate(root, info, thread_id, content, attachment=None): thread = Thread.objects.filter(pk=thread_id) thread = thread.filter(members=info.context.user).get() created_by = info.context.user created_at = timezone.now() message = Message(thread=thread, created_by=created_by, created_at=created_at, content=content, attachment=attachment) message.save() return CreateMessage(message=message)
def bid(request, hex, item): try: char = gtc(request) item = get_object_or_404(Item, id=item) node_hex = get_object_or_404(Node, hex=hex) amount = int(request.POST.get("amount", 0)) bid_x = char.bid_on(node_hex, item, amount) messages.success(request, "Bid confirmed!") Message.mail_to(char, "Market Bid Confirmed", "Your bid of %s on %s has been confirmed. %s" % (amount, item, "You were disguised when you bid." if bid_x.disguised else ""), sender="Bakaara Market") char.revert_disguise(request) except Exception, e: messages.error(request, "Something went wrong and your bid was not processed: %s" % e.message)
def POST(self, request): """ Parses the JSON request to create a Message object """ item = Message() item.parse(request) if not item: return http.HttpResponseBadRequest() item.save() return http.HttpResponse(status=StatusCodes.CREATED)
def new_message(request): args = {} if request.method == 'POST': form = NewMessageForm(request.POST) if form.is_valid(): message = Message(user_from=request.user.username, user_to=form.cleaned_data["user_to"], content=form.cleaned_data["message"], date=datetime.datetime.now()) message.save() args["form"] = NewMessageForm() args["success"] = True else: args["form"] = NewMessageForm() return render(request, "new_message.html", args)
def disband_units(self): for faction in Faction.objects.all(): if faction.code == 'ET': continue # ET gets a pass, ha ha if faction.units() > faction.allowed_units(): to_disband = faction.units() - faction.allowed_units() disbandees = faction.unit_set.filter(alive=True).order_by('disband_priority')[:to_disband] for d in disbandees: d.alive = False d.save() try: Message.mail_line(faction.controller, "%s units disbanded" % disbandees.count(), "You were over your cap, so units in the following territories were disbanded:\n%s" % "\n".join([d.territory.name for d in list(disbandees)])) except Exception, e: print e, type(e), e.message
def mail_home(request, template="messaging/mail_home.html"): char = gtc(request) context = { # 'special_mailboxes': Mailbox.objects.filter(public=True, type=0).order_by('name'), 'char_mailboxes': Mailbox.objects.filter(public=True, type=1).order_by('name'), 'group_mailboxes': Mailbox.objects.filter(public=True, type=2).order_by('name'), 'send_mailboxes': Mailbox.objects.filter( Q(character=char) | Q(line__lineorder__order=1, line__lineorder__character=char)). order_by('type'), 'read_mailboxes': Mailbox.objects.filter( Q(character=char) | Q(line__lineorder__character=char)) } if request.method == 'POST': try: context['mail_text'] = request.POST.get('text') new_mail = Message() new_mail.sender = Mailbox.objects.get( code=request.POST.get('from_code')) try: new_mail.to = Mailbox.objects.get( code=request.POST.get('to_code')) except Mailbox.DoesNotExist: try: new_mail.to = Mailbox.objects.get( name=request.POST.get('to_name')) except Mailbox.DoesNotExist: raise ValidationError("That mailbox doesn't exist.") new_mail.text = request.POST.get('text') new_mail.subject = request.POST.get('subject') new_mail.anon = request.POST.get('anon') == 'on' new_mail.save() if new_mail.anon: check_inspiration(request) try: subprocess.Popen([ 'zwrite', '-d', '-c', 'consortium-sekrit-auto', '-m', "Mail from %s to %s\nSubject: %s\n%s" % (new_mail.sender.name, new_mail.to.name, new_mail.subject, new_mail.text.replace('"', "'")) ]) except: pass messages.success(request, "Sent mail to %s" % new_mail.to.name) context['mail_text'] = '' except ValidationError, e: messages.error(request, e.messages[0])
def generate_resources(self): for faction in Faction.objects.all(): generated = [] for territory in faction.territory_set.filter(special=MINE): generated.append( "%s generates %s" % (territory.name, territory.resource_generated())) try: Message.mail_line( faction.controller, "Resources Generated", "Your territories generated the following resources:\n%s" % "\n".join(generated)) except: pass
def check_and_notify(self): if self.notified == True: return False for s in self.overlaps(): if s.creator.alive: Message.mail_to( s.creator, "Security Alarm: %s" % self.location, "Security alert! Entry window detected; possible breach attempt in progress at %s, start time: %s" % (self.location, localtime(self.start_time)), sender="Security", urgent=True) self.notified = True self.save() return True
def create_messages(self, message_text): ret = None for user in self.room_cache.users.all(): message = Message( user=user, message=message_text, is_watched=0, room=self.room_cache ) if user == self.user_cache: message.is_watched = 1 ret = message message.save() return ret
def save(self, *args): # Override save: apply immediately and return self.player.money -= self.amount self.player.save() self.recipient.money += self.amount self.recipient.save() m = Message( title="Transfert d'argent", content="Un transfert de %s k¥ a été effectué de %s vers %s" % (self.amount, self.player, self.recipient), turn=self.player.game.current_turn, flag=Message.CASH_TRANSFER, ) m.save() m.recipient_set.add(self.player, self.recipient)
def test_send_message_all(self): subject = 'I want him dead!' body = 'The Imp, that is. Incase you were wondering.' t0 = timezone.now() message = Message.send_message_all(sender=self.users['Cersei'], subject=subject, body=body) # check the Message itself self.assertIsInstance(message, Message) self.assertEqual(self.users['Cersei'].id, message.user.id) self.assertFalse(message.is_notification) self.assertEqual('', message.url) self.assertEqual(subject, message.subject) self.assertEqual(body, message.body) self.assertGreaterEqual(message.sent, t0) self.assertTrue(message.target_all) # check there's a MessageItem for each recipient message_item = MessageItem.objects.filter( message=message, read=None, deleted=None).order_by('user__first_name') self.assertEqual(len(self.users), message_item.count()) # check there's no MessageTargetUser, MessageTargetCourse, MessageTargetGroup self.assertEqual(0, MessageTargetUser.objects.all().count()) self.assertEqual(0, MessageTargetCourse.objects.all().count()) self.assertEqual(0, MessageTargetGroup.objects.all().count())
def test_get_unread_message_item_count_for_message_trees(self): # create another thread recipients = [{'id': self.users['Cersei'].id, 'type': u'u'}] thread2 = Message.send_message(sender=self.users['Tywin'], recipients=recipients, subject='Loras Tyrell', body='Marry him!') # get a list of tree ids tree_ids = [self.thread.tree_id, thread2.tree_id] # read a message mi = MessageItem.objects.get(user=self.users['Cersei'], message=self.thread) mi.read = timezone.now() mi.save() # get counts of unread message items and unread message items in each thread in the inbox page undeleted_dict = MessageItem.get_unread_message_item_count_for_message_trees( self.users['Cersei'], tree_ids) self.assertEqual(2, len(undeleted_dict)) self.assertDictEqual({ self.thread.tree_id: 3, thread2.tree_id: 1, }, undeleted_dict)
def send_message(request): if request.is_ajax(): if request.GET.get('receiver') == "": messages.error(request, "Select a conversation, please") return HttpResponseRedirect('/messaging/inbox/') else: receiver = get_object_or_404(User, username=request.GET.get('receiver')) if request.method == 'GET': message = Message(sender=request.user, receiver=receiver, msg_content=request.GET.get('msg'), created_at=datetime.datetime.now()) message.save() return HttpResponse(json.dumps("success", cls=DjangoJSONEncoder), content_type='application/json') else: return HttpResponseRedirect('/messaging/inbox/')
class SendTestCase(TestCase): def setUp(self): self.user1 = User.objects.create_user('user1', '*****@*****.**', '123456') self.user2 = User.objects.create_user('user2', '*****@*****.**', '123456') self.msg1 = Message(sender=self.user1, recipient=self.user2, subject='Subject Text', body='Body Text') self.msg1.save() def testBasic(self): self.assertEquals(self.msg1.sender, self.user1) self.assertEquals(self.msg1.recipient, self.user2) self.assertEquals(self.msg1.subject, 'Subject Text') self.assertEquals(self.msg1.body, 'Body Text') self.assertEquals(self.user1.sent_messages.count(), 1) self.assertEquals(self.user1.received_messages.count(), 0) self.assertEquals(self.user2.received_messages.count(), 1) self.assertEquals(self.user2.sent_messages.count(), 0)
def create(self, validated_data): tags = validated_data.pop("tags", []) message = Message(**validated_data) thread = validated_data.get("thread") message = Message.objects.send(message, thread, tags=tags) return message
def test_send_is_silenced(self): recipient = create_user('user', 'email', 'password') sender = create_user('sender', 'email', 'password') f = Message.inform_recipient inform_mock = mock.MagicMock() Message.inform_recipient = inform_mock Message.create_message(sender, recipient, 'text1') inform_mock.assert_called_once() inform_mock.reset_mock() Message.create_message(sender, recipient, 'text2') inform_mock.assert_not_called() Message.inform_recipient = f
def test_send_is_not_silenced_after_half_an_hour(self): recipient = create_user('user', 'email', 'password') sender = create_user('sender', 'email', 'password') f = Message.inform_recipient inform_mock = mock.MagicMock() Message.inform_recipient = inform_mock sent_time = timezone.now() - datetime.timedelta(minutes=31) Message.create_message(sender, recipient, 'text1', sent_time) inform_mock.assert_called_once() inform_mock.reset_mock() Message.create_message(sender, recipient, 'text2') inform_mock.assert_called_once() Message.inform_recipient = f
def build_units(self): for faction in Faction.objects.all(): if not BuildOrder.objects.filter(faction=faction, turn=self.turn).exists(): continue built = [] for b in BuildOrder.objects.filter(faction=faction, turn=self.turn): if b.territory.owner != faction: built.append("%s: failed, territory not yours" % b.territory.name) elif b.territory.has_unit: built.append("%s: failed, territory still occupied" % b.territory.name) else: built.append("%s: succeeded" % b.territory.name) Unit.objects.create(faction=faction, territory=b.territory) try: Message.mail_line(faction.controller, "Unit Build Results", "Your build orders:\n%s" % "\n".join(built)) except: pass
def setUp(self): # Oberyn self.oberyn = get_user_model().objects.create_user( username='******', email='*****@*****.**', first_name='Oberyn', last_name='Martell', password=self.password) # the Sand Snakes self.sand_snakes = {} for first_name in [u'Nymeria', u'Tyene', u'Obara']: u = get_user_model().objects.create_user( username='******' % first_name.lower(), email='*****@*****.**' % first_name.lower(), first_name=first_name, last_name='Sand', password=self.password) self.sand_snakes[first_name] = u # Sand Snake recipients self.sand_snake_recipients = list( map(lambda p: { 'id': p[1].id, 'type': u'u' }, iteritems(self.sand_snakes))) # create a thread of messages self.thread = Message.send_message( sender=self.oberyn, recipients=self.sand_snake_recipients, subject='Justice for Elia', body='') self.thread.sent = datetime(year=2014, month=7, day=28, hour=9, minute=0, second=0).replace(tzinfo=utc) self.thread.save() # create a thread that won't be the focus of this test case Message.send_message(sender=self.oberyn, recipients=self.sand_snake_recipients, subject='Poison', body='Anyone got any spare?')
def messages_view(request): if not request.user.is_authenticated(): return redirect('login') if request.method == 'POST': form = MessageForm(data=request.POST) if form.is_valid(): subject = form.cleaned_data['subject'] to = form.cleaned_data['to'] body = form.cleaned_data['body'] send_to = User.objects.filter(username=to) if send_to.count() != 0: msg = Message() msg.msg_from = request.user msg.msg_to = send_to[0] msg.body = body msg.subject = subject msg.save() messages.add_message(request, messages.SUCCESS, 'Message sent Successfully', extra_tags='alert-success') else: messages.add_message(request, messages.WARNING, 'User Does Not Exist.', extra_tags='alert-danger') else: messages.add_message(request, messages.WARNING, 'One or More Invalid Field(s).', extra_tags='alert-danger') return redirect('messaging:messages') template = loader.get_template('base_messages_inbox.html') message_q = Message.objects.filter(msg_to=request.user)[:50] if message_q.count() != 0: message_list = list(message_q) message_list.reverse() args = {'user_messages': message_list} else: args = {} context = RequestContext(request, args) return HttpResponse(template.render(context))
def test_new_message_email_new_messaging_system(self): recipient = create_user('user', 'email', 'password') sender = create_user('sender', 'email', 'password') m = Message.create_message(sender, recipient, 'text', silent=True) nme = NewMessageEmail(m) self.assertIn('https://rbe-network.org/messaging/conversation/{}'.format(m.sender.id), nme.body_html())
def gm_mail_home(request, template="messaging/mail_home.html"): if not request.user.is_superuser: raise Http404 context = { 'special_mailboxes': Mailbox.objects.filter(public=True, type=0).order_by('name'), 'char_mailboxes': Mailbox.objects.filter(public=True, type=1).order_by('name'), 'group_mailboxes': Mailbox.objects.filter(public=True, type=2).order_by('name'), 'send_mailboxes': Mailbox.objects.all(), 'read_mailboxes': Mailbox.objects.all() } if request.method == 'POST': try: context['mail_text'] = request.POST.get('text') new_mail = Message() new_mail.sender = Mailbox.objects.get( code=request.POST.get('from_code')) try: new_mail.to = Mailbox.objects.get( code=request.POST.get('to_code')) except Mailbox.DoesNotExist: try: new_mail.to = Mailbox.objects.get( name=request.POST.get('to_name')) except Mailbox.DoesNotExist: raise ValidationError("That mailbox doesn't exist.") new_mail.text = request.POST.get('text') new_mail.subject = request.POST.get('subject') print request.POST.get('anon') == 'on' new_mail.anon = request.POST.get('anon') == 'on' new_mail.save() subprocess.Popen([ 'zwrite', '-d', '-c', 'consortium-sekrit-auto', '-m', "Mail from %s to %s\nSubject: %s\n%s" % (new_mail.sender.name, new_mail.to.name, new_mail.subject, new_mail.text.replace('"', "'")) ]) messages.success(request, "Sent mail to %s" % new_mail.to.name) context['mail_text'] = '' except ValidationError, e: messages.error(request, e.messages[0])
def test_email_thread(self, mock_send_mass_mail): # create a message message = Message.objects.create( user=self.users['Cersei'], subject='The High Sparrow', body='He is a little self-righteous, is he not?', parent=None) # email the thread (which obviously only consists of one message) all_user_ids = list( map(lambda k: self.users[k].pk, ['Kevan', 'Jaime', 'Tywin'])) Message.email_thread(message, all_user_ids) # ensure send_mass_mail was called with a tuple of 3 tuples as its first argument emails = get_user_model().objects.filter( pk__in=all_user_ids).values_list('email', flat=True) l = [(ANY, ANY, None, [email]) for email in emails] mock_send_mass_mail.assert_called_once_with(tuple(l), fail_silently=True)
def reply(request): sent_from = request.user #sent with ajax request if request.method == 'POST' and request.is_ajax(): new_message = MessageForm(request.POST) id = request.POST.get('name') #gets the message that this one is replying to old_message = Message.objects.get(id=id) #the old message's 'from' becomes this message's 'to' send_to = old_message.sent_from if new_message.is_valid(): subject = new_message.cleaned_data['subject'] message = new_message.cleaned_data['message'] new_msg = Message(send_to=send_to, sent_from=sent_from, subject=subject, message=message, is_sent=True) #indicates which message this one is replying to new_msg.is_reply = old_message new_msg.save() return HttpResponse('sent') return HttpResponse('...')
def check_collisions_and_notify(new_window): query_set = new_window.overlaps() if isinstance(new_window, EntryWindow): for s in query_set: Message.mail_to( s.creator, "Security Window Triggered", "Security alert! Possible breach attempt at %s, time: %s" % (new_window.location, new_window.start_time), sender="Security") elif isinstance(new_window, SecurityWindow): for e in query_set: Message.mail_to( new_window.creator, "Security Window Triggered", "Security alert! Possible breach attempt at %s, time: %s" % (new_window.location, e.start_time), sender="Security") return query_set
def disband_units(self): for faction in Faction.objects.all(): if faction.code == 'ET': continue # ET gets a pass, ha ha if faction.units() > faction.allowed_units(): to_disband = faction.units() - faction.allowed_units() disbandees = faction.unit_set.filter( alive=True).order_by('disband_priority')[:to_disband] for d in disbandees: d.alive = False d.save() try: Message.mail_line( faction.controller, "%s units disbanded" % disbandees.count(), "You were over your cap, so units in the following territories were disbanded:\n%s" % "\n".join([d.territory.name for d in list(disbandees)])) except Exception, e: print e, type(e), e.message
def test_update_status_code(self, session): msg = Message(sender='21981527318', receiver='21980072800', body='Hello World!') session.add(msg) session.commit() repo = MessageRepository() msg = repo.update_status_code(id=1, status_code=201) assert msg is None assert Message.query.get(1).status_code == 201
def test_seen_mentions(self): thread = self.channel seen_date = timezone.now() with self.assertRaises(UnexistentMembership): Membership.objects.see_thread(self.mehdi, thread, seen_date) with self.assertRaises(ExistingMember): adam_membership = Membership.objects.create_membership(self.adam, thread) mehdi_membership = Membership.objects.create_membership(self.mehdi, thread) first_message = Message.objects.send(Message(contents="Salut"), thread, self.mehdi) second_message = Message.objects.send(Message(contents="Hey :)"), thread, self.adam) seen_date = timezone.now() Membership.objects.see_thread(self.adam, thread, seen_date, last_seen_message=second_message) third_message = Message.objects.send(Message(contents="Ca va ?"), thread, self.mehdi) self.assertFalse(Membership.objects.has_seen_thread(self.adam, thread)) memb = Membership.objects.get_membership(self.adam, thread) # raise Exception("Memb last seen date is %s while message sent date is %s" % (memb.last_seen_date, first_message.sent_date)) self.assertTrue(Membership.objects.has_seen_message(self.adam, first_message)) self.assertTrue(Membership.objects.has_seen_message(self.adam, second_message)) self.assertFalse(Membership.objects.has_seen_message(self.adam, third_message)) same_seen_date = Membership.objects.get_last_seen_date(self.adam, thread) self.assertEqual(same_seen_date, seen_date) adam_membership = Membership.objects.get_membership(self.adam, thread) self.assertEqual(adam_membership.last_seen_date, seen_date) self.assertEqual(adam_membership.last_seen_message.pk, second_message.pk) self.assertEqual(adam_membership.unchecked_count, 1) fourth_message = Message.objects.send(Message(contents="Ca va et toi ?"), thread, self.mehdi) self.assertEqual(adam_membership.unchecked_count, 2)
def form_valid(self, form): person = form.cleaned_data['token'].person cable = form.cleaned_data['reader'].cable_system session, cost = CableSystemSession.objects.toggle_active(person=person, cable=cable) if session.person.account.balance < 0: Message.create_message( body=_("Insufficient funds to pay for use of the system"), recipients=list(User.objects.filter(is_staff=True, is_active=True)), content_object=session.person, request=self.request) if self.request.is_ajax(): data = {'person': unicode(session.person), 'cable': unicode(cable), 'active': session.active} return self.render_to_json_response(data) return self.render_on_success(person=session.person, cable=cable, active=session.active)
def send(request): recipient_id = request.POST.get('recipient_id') message_text = request.POST.get('message_text') error_message = '' try: if not message_text: error_message = 'Empty message cannot be sent!' elif len(message_text) > 1200: error_message = 'A message cannot be longer than 1200 characters!' else: recipient = User.objects.get(id=recipient_id) Message.create_message(request.user, recipient, message_text) return redirect(reverse('conversation', kwargs={'user_id': recipient.id})) except User.DoesNotExist as e: rbe_logger.warning("Had problems") error_message = "User to write to doesn't exists" except Exception as e: error_message = "Unknown error occurred - please try again later" rbe_logger.exception(e) return conversation(request, recipient_id, error_message)
def new_complaint(request): geolocator = GoogleV3() fellows = [] time = datetime.time(datetime.now()) date = datetime.date(datetime.now()) if request.method == 'POST' and request.is_ajax: complaint = ComplaintForm(request.POST) if complaint.is_valid(): situation = complaint.cleaned_data['situation'] neighborhood = complaint.cleaned_data['neighborhood'] apt_number = complaint.cleaned_data['apt_number'] street_address = complaint.cleaned_data['street_address'] new_complaint = Complaint(situation=situation, neighborhood=neighborhood, street_address=street_address, date=date, time=time) if request.user.is_authenticated: new_complaint.owner = request.user if apt_number: new_complaint.apt_number = apt_number apts = Complaint.objects.filter(street_address=street_address).filter(apt_number=apt_number) numbers = [apt.apt_number for apt in apts] if apt_number in numbers: new_complaint.others = True if new_complaint.others: for a in apts: if a.owner not in fellows: fellows.append(a.owner) for fellow in fellows: new_msg = Message(sent_from=request.user, send_to=fellow, subject="another complaint about %s" % new_complaint.street_address, message="you are not alone! Others have also complained about %s. Reply to this message so you guys can figure out what to do about it." % new_complaint.street_address) new_complaint.save() new_msg.complaint = new_complaint new_msg.save() data = json.dumps({"situation": situation, "neighborhood": neighborhood, "time": str(new_complaint.time)}) if new_complaint.street_address: nycaddress = new_complaint.street_address + " NYC" geoAddress = nycaddress, (latitude, longitude) = geolocator.geocode(nycaddress) way = WayPoint(complaint=new_complaint) way.geometry = 'POINT(%s %s)' % (latitude, longitude) way.save() return HttpResponse(data, content_type='application/json') return HttpResponse("...")
def test_message_author_game_equals_player_game(self): """ Check if author's game = player's game """ p2 = Player(game=self.g) p2.save() g2 = Game() g2.save() p3 = Player(game=g2) p3.save() m = Message(title="titre", author=self.p, turn=self.g.current_turn) m.save() m.recipient_set.add(p2) m.save() m2 = Message(title="titre1", author=self.p, turn=self.g.current_turn) m2.save() self.assertRaises(IntegrityError, lambda: m2.recipient_set.add(p3))
def test_retrieving_messages_page_works_with_read_message(self, smc): recipient = create_user('user', 'email', 'password') sender = create_user('sender', 'email', 'password') m = Message.create_message(sender, recipient, 'text', silent=True) m.status = MessageStatus.READ m.save() c = Client() c.login(username='******', password='******') response = c.get(reverse('messages')) self.assertEqual(response.status_code, 200)
def build_resolution_message(self): """ Retrieve all notes addressed to the player for this turn, and build a message to remember them. """ self.add_note(content="Argent disponible pour le tour : %sk¥" % self.money) notes = Note.objects.filter(recipient_set=self, turn=self.game.current_turn) m = Message.build_message_from_notes( message_type=Message.RESOLUTION, notes=notes, title="Message de résolution du tour %s" % self.game.current_turn, turn=self.game.current_turn ) m.recipient_set.add(self) return m
def test_message_building_content(self): """ Check content is built in right order """ Note.objects.create( content="global", turn=self.g.current_turn ) Note.objects.create( category=Note.SPECULATION, content="speculation", turn=self.g.current_turn ) Note.objects.create( category=Note.RUNS, content="runs", turn=self.g.current_turn ) Note.objects.create( category=Note.DIVIDEND, content="dividend", turn=self.g.current_turn ) opening = "Opening" m = Message.build_message_from_notes( message_type=Message.RESOLUTION, notes=Note.objects.all(), opening=opening, title="test", turn=self.g.current_turn ) expected = u"""Opening * global ### Runs * runs ### Spéculations * speculation ### Dividendes * dividend""" self.assertEqual(m.content.strip(), expected)
def test_confirming_unread_works(self, smc): recipient = create_user('recipient', 'email', 'password') sender = create_user('sender', 'email', 'password') m = Message.create_message(sender, recipient, 'text', silent=True) self.assertEqual(m.status, MessageStatus.UNREAD) c = Client() c.login(username='******', password='******') qd = MultiValueDict({'message_ids[]': [m.id]}) response = c.post(reverse('messaging_confirm_read'), qd) self.assertEqual(response.status_code, 200) m.refresh_from_db() self.assertEqual(m.status, MessageStatus.READ)
def mail_home(request, template="messaging/mail_home.html"): char = gtc(request) context = { # 'special_mailboxes': Mailbox.objects.filter(public=True, type=0).order_by('name'), 'char_mailboxes': Mailbox.objects.filter(public=True, type=1).order_by('name'), 'group_mailboxes': Mailbox.objects.filter(public=True, type=2).order_by('name'), 'send_mailboxes': Mailbox.objects.filter(Q(character=char) | Q(line__lineorder__order=1, line__lineorder__character=char)).order_by('type'), 'read_mailboxes': Mailbox.objects.filter(Q(character=char) | Q(line__lineorder__character=char)) } if request.method == 'POST': try: context['mail_text'] = request.POST.get('text') new_mail = Message() new_mail.sender = Mailbox.objects.get(code=request.POST.get('from_code')) try: new_mail.to = Mailbox.objects.get(code=request.POST.get('to_code')) except Mailbox.DoesNotExist: try: new_mail.to = Mailbox.objects.get(name=request.POST.get('to_name')) except Mailbox.DoesNotExist: raise ValidationError("That mailbox doesn't exist.") new_mail.text = request.POST.get('text') new_mail.subject = request.POST.get('subject') new_mail.anon = request.POST.get('anon') == 'on' new_mail.save() if new_mail.anon: check_inspiration(request) try: subprocess.Popen(['zwrite', '-d', '-c', 'consortium-sekrit-auto', '-m', "Mail from %s to %s\nSubject: %s\n%s" % (new_mail.sender.name, new_mail.to.name, new_mail.subject, new_mail.text.replace('"', "'"))]) except: pass messages.success(request, "Sent mail to %s" % new_mail.to.name) context['mail_text'] = '' except ValidationError, e: messages.error(request, e.messages[0])
class DeleteTestCase(TestCase): def setUp(self): self.user1 = User.objects.create_user('user3', '*****@*****.**', '123456') self.user2 = User.objects.create_user('user4', '*****@*****.**', '123456') self.msg1 = Message(sender=self.user1, recipient=self.user2, subject='Subject Text 1', body='Body Text 1') self.msg2 = Message(sender=self.user1, recipient=self.user2, subject='Subject Text 2', body='Body Text 2') self.msg1.sender_deleted_at = datetime.datetime.now() self.msg2.recipient_deleted_at = datetime.datetime.now() self.msg1.save() self.msg2.save() def testBasic(self): self.assertEquals(Message.objects.outbox_for(self.user1).count(), 1) self.assertEquals(Message.objects.outbox_for(self.user1)[0].subject, 'Subject Text 2') self.assertEquals(Message.objects.inbox_for(self.user2).count(),1) self.assertEquals(Message.objects.inbox_for(self.user2)[0].subject, 'Subject Text 1') #undelete self.msg1.sender_deleted_at = None self.msg2.recipient_deleted_at = None self.msg1.save() self.msg2.save() self.assertEquals(Message.objects.outbox_for(self.user1).count(), 2) self.assertEquals(Message.objects.inbox_for(self.user2).count(),2)