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 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 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 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)
