def reply(request, message_id, form_class=ComposeForm,
template_name='messages/compose.html', success_url=None, recipient_filter=None):
parent = get_object_or_404(Message, id=message_id)
if parent.sender != request.user and parent.recipient != request.user:
raise Http404
if request.method == 'POST':
sender = request.user
form = form_class(request.POST, recipient_filter=recipient_filter, sender=request.user)
if form.is_valid():
form.save(sender=request.user, parent_msg=parent)
request.user.message_set.create(
message=_(u"Message successfully sent."))
if success_url is None:
success_url = reverse('messages_inbox')
return HttpResponseRedirect(success_url)
else:
form = form_class({'body': _(u"%(sender)s wrote:\n%(body)s") % {'sender': parent.sender.visible_name(),
'body': format_quote(parent.body)
},
'subject': _(u"Re: %(subject)s") % {'subject': parent.subject},
'recipient': [parent.sender,]
})
return render_to_response(template_name,
{'form': form,},
context_instance=RequestContext(request))
def reply(request, message_id, form_class=ComposeForm,
template_name='messages/compose.html', success_url=None, recipient_filter=None):
"""
Prepares the ``form_class`` form for writing a reply to a given message
(specified via ``message_id``). Uses the ``format_quote`` helper from
``messages.utils`` to pre-format the quote.
"""
from messages.utils import format_quote
parent = get_object_or_404(Message, id=message_id)
if parent.sender != request.user and parent.recipient != request.user:
raise Http404
if request.method == "POST":
sender = request.user
form = form_class(request.POST)
if form.is_valid():
form.save(sender=request.user, parent_msg=parent)
request.user.message_set.create(
message=_(u"Message successfully sent."))
if success_url is None:
success_url = reverse('messages_inbox')
return HttpResponseRedirect(success_url)
else:
form = form_class({
'body': _(u"%(sender)s wrote:\n%(body)s") % {
'sender': parent.sender.get_profile().role.name,
'body': format_quote(parent.body)
},
'subject': _(u"Re: %(subject)s") % {'subject': parent.subject},
'recipient': parent.sender.get_profile().role_id
})
return render_to_response(request, template_name, {
'form': form,
})
def reply(request, message_id, form_class=ComposeForm,
template_name='messages/compose.html', success_url=None):
"""
Prepares the ``form_class`` form for writing a reply to a given message
(specified via ``message_id``). Uses the ``format_quote`` helper from
``messages.utils`` to pre-format the quote.
"""
parent = get_object_or_404(Message, id=message_id)
if request.method == "POST":
sender = request.user
form = form_class(request.POST)
if form.is_valid():
form.save(sender=request.user, parent_msg=parent)
request.user.message_set.create(
message=_(u"Message successfully sent."))
if success_url is None:
success_url = reverse('messages_inbox')
return HttpResponseRedirect(success_url)
else:
form = form_class({
'body': _(u"%(sender)s wrote:\n%(body)s") % {
'sender': parent.sender,
'body': format_quote(parent.body)
},
'subject': _(u"Re: %(subject)s") % {'subject': parent.subject},
'recipient': [parent.sender,]
})
return render_to_response(template_name, {
'form': form,
}, context_instance=RequestContext(request))
def testReply(self):
""" test that user_2 can reply """
# create a message for this test
Message.objects.create(
sender=self.user_1,
recipient=self.user_2,
subject=self.T_MESSAGE_DATA[0]["subject"],
body=self.T_MESSAGE_DATA[0]["body"],
)
# log the user_2 in and check the inbox
self.c.login(username=self.T_USER_DATA[1]["username"], password=self.T_USER_DATA[1]["password"])
response = self.c.get(reverse("messages_inbox"))
self.assertEquals(response.status_code, 200)
self.assertEquals(response.templates[0].name, "messages/inbox.html")
self.assertEquals(len(response.context["message_list"]), 1)
pk = getattr(response.context["message_list"][0], "pk")
# reply to the first message
response = self.c.get(reverse("messages_reply", kwargs={"message_id": pk}))
self.assertEquals(response.status_code, 200)
self.assertEquals(response.templates[0].name, "messages/compose.html")
self.assertEquals(
response.context["form"].initial["body"], format_quote(self.user_1, self.T_MESSAGE_DATA[0]["body"])
)
self.assertEqual(
response.context["form"].initial["subject"],
u"Re: %(subject)s" % {"subject": self.T_MESSAGE_DATA[0]["subject"]},
)
def reply(request, message_id, form_class=ComposeForm,
template_name='messages/compose.html', success_url=None):
"""
Prepares the ``form_class`` form for writing a reply to a given message
(specified via ``message_id``). Uses the ``format_quote`` helper from
``messages.utils`` to pre-format the quote.
"""
parent = get_object_or_404(Message, id=message_id)
if request.method == "POST":
sender = request.user
form = form_class(request.POST)
if form.is_valid():
form.save(sender=request.user, parent_msg=parent)
request.user.message_set.create(
message=_(u"Message successfully sent."))
if success_url is None:
success_url = reverse('messages_all')
return HttpResponseRedirect(success_url)
else:
form = form_class({
'body': _(u"%(sender)s wrote:\n%(body)s") % {
'sender': parent.sender,
'body': format_quote(parent.body)
},
'subject': _(u"Re: %(subject)s") % {'subject': parent.subject},
'recipient': [parent.sender,]
})
return render_to_response(template_name, {
'form': form,
}, context_instance=RequestContext(request))
def testReply(self):
""" test that user_2 can reply """
# create a message for this test
Message.objects.create(sender=self.user_1,
recipient=self.user_2,
subject=self.T_MESSAGE_DATA[0]['subject'],
body=self.T_MESSAGE_DATA[0]['body'])
# log the user_2 in and check the inbox
self.c.login(username=self.T_USER_DATA[1]['username'],
password=self.T_USER_DATA[1]['password'])
response = self.c.get(reverse('messages_inbox'))
self.assertEquals(response.status_code, 200)
self.assertEquals(response.template[0].name, 'messages/inbox.html')
self.assertEquals(len(response.context['message_list']), 1)
pk = getattr(response.context['message_list'][0], 'pk')
# reply to the first message
response = self.c.get(
reverse('messages_reply', kwargs={'message_id': pk}))
self.assertEquals(response.status_code, 200)
self.assertEquals(response.template[0].name, 'messages/compose.html')
self.assertEquals(
response.context['form'].initial['body'],
format_quote(self.user_1, self.T_MESSAGE_DATA[0]['body']))
self.assertEqual(
response.context['form'].initial['subject'], u"Re: %(subject)s" %
{'subject': self.T_MESSAGE_DATA[0]['subject']})
def GET(self, message_id, form_class=ComposeForm,
template_name='messages/compose.html', success_url=None, recipient_filter=None):
"""
Prepares the ``form_class`` form for writing a reply to a given message
(specified via ``message_id``). Uses the ``format_quote`` helper from
``messages.utils`` to pre-format the quote.
"""
parent = get_object_or_404(Message, id=message_id)
if parent.sender != self.request.user and parent.recipient != self.request.user:
raise Http404
form = form_class({
'body': _(u"%(sender)s wrote:\n%(body)s") % {
'sender': parent.sender,
'body': format_quote(parent.body)
},
'subject': _(u"Re: %(subject)s") % {'subject': parent.subject},
'recipient': [parent.sender,]
})
return self.context_response(template_name, {
'form': form,
'current_tab': 'messages',
'subtab': 'new'
})
def reply(request, message_id, form_class=ComposeForm,
template_name='messages/compose.html', success_url=None, recipient_filter=None):
"""
Prepares the ``form_class`` form for writing a reply to a given message
(specified via ``message_id``). Uses the ``format_quote`` helper from
``messages.utils`` to pre-format the quote.
"""
parent = get_object_or_404(Message, id=message_id)
if parent.sender != request.user and parent.recipient != request.user:
raise Http404
if request.method == "POST":
sender = request.user
form = form_class(request.POST, recipient_filter=recipient_filter)
if form.is_valid():
form.save(sender=request.user, parent_msg=parent)
messages.success(request, _(u'Message successfully sent.'))
if success_url is None:
success_url = reverse('messages_inbox')
#send_mail('You have a new message waiting at HelloLocals.com!', 'Here is the message.', '*****@*****.**', ['*****@*****.**'], fail_silently=False)
return HttpResponseRedirect(success_url)
else:
form = form_class({
'body': _(u"%(sender)s wrote:\n%(body)s") % {
'sender': parent.sender,
'body': format_quote(parent.body)
},
'subject': _(u"Re: %(subject)s") % {'subject': parent.subject},
'recipient': [parent.sender,]
})
return render_to_response(template_name, {
'form': form,
}, context_instance=RequestContext(request))
def reply(request,
message_id,
form_class=ComposeForm,
template_name='messages/compose.html',
success_url=None,
recipient_filter=None):
parent = get_object_or_404(Message, id=message_id)
if parent.sender != request.user and parent.recipient != request.user:
raise Http404
if request.method == 'POST':
sender = request.user
form = form_class(request.POST,
recipient_filter=recipient_filter,
sender=request.user)
if form.is_valid():
form.save(sender=request.user, parent_msg=parent)
request.user.message_set.create(
message=_(u"Message successfully sent."))
if success_url is None:
success_url = reverse('messages_inbox')
return HttpResponseRedirect(success_url)
else:
form = form_class({
'body': _(u"%(sender)s wrote:\n%(body)s") % {
'sender': parent.sender.visible_name(),
'body': format_quote(parent.body)
},
'subject': _(u"Re: %(subject)s") % {
'subject': parent.subject
},
'recipient': [
parent.sender,
]
})
return render_to_response(template_name, {
'form': form,
},
context_instance=RequestContext(request))
def reply(
request,
message_id,
form_class=ComposeForm,
template_name="messages/compose.html",
success_url=None,
recipient_filter=None,
):
"""
Prepares the ``form_class`` form for writing a reply to a given message
(specified via ``message_id``). Uses the ``format_quote`` helper from
``messages.utils`` to pre-format the quote.
"""
parent = get_object_or_404(Message, id=message_id)
if parent.sender != request.user and parent.recipient != request.user:
raise Http404
if request.method == "POST":
sender = request.user
form = form_class(request.POST, recipient_filter=recipient_filter)
if form.is_valid():
form.save(sender=request.user, parent_msg=parent)
request.user.message_set.create(message=_(u"Message successfully sent."))
if success_url is None:
success_url = reverse("messages_inbox")
return HttpResponseRedirect(success_url)
else:
form = form_class(
{
"body": _(u"%(sender)s wrote:\n%(body)s")
% {"sender": parent.sender, "body": format_quote(parent.body)},
"subject": _(u"Re: %(subject)s") % {"subject": parent.subject},
"recipient": [parent.sender],
}
)
return render_to_response(template_name, {"form": form}, context_instance=RequestContext(request))
def testReply(self):
""" test that user_2 can reply """
# create a message for this test
Message.objects.create(sender=self.user_1,
recipient=self.user_2,
subject=self.T_MESSAGE_DATA[0]['subject'],
body=self.T_MESSAGE_DATA[0]['body'])
# log the user_2 in and check the inbox
self.c.login(username=self.T_USER_DATA[1]['username'],
password=self.T_USER_DATA[1]['password'])
response = self.c.get(reverse('messages_inbox'))
self.assertEquals(response.status_code, 200)
self.assertEquals(response.templates[0].name, 'messages/inbox.html')
self.assertEquals(len(response.context['message_list']), 1)
pk = getattr(response.context['message_list'][0], 'pk')
# reply to the first message
response = self.c.get(reverse('messages_reply',
kwargs={'message_id':pk}))
self.assertEquals(response.status_code, 200)
self.assertEquals(response.templates[0].name, 'messages/compose.html')
self.assertEquals(response.context['form'].initial['body'],
format_quote(self.user_1, self.T_MESSAGE_DATA[0]['body']))
self.assertEqual(response.context['form'].initial['subject'],
u"Re: %(subject)s"%{'subject': self.T_MESSAGE_DATA[0]['subject']})
def in_out_trash_comp(request, recipient=None, message_id=None, form_class=ComposeForm,
template_name='messages/messages.html', success_url=None):
"""
combines inbox, outbox, trash and compose
"""
system_messages = []
for ms in request.user.message_set.all() :
system_messages.append(ms)
if request.method == "POST":
sender = request.user
form = form_class(request.POST)
if form.is_valid():
form.save(sender=request.user)
request.user.message_set.create(
message=_(u"Message successfully sent."))
if success_url is None:
success_url = reverse('messages_all')+'#tabview=inbox'
return HttpResponseRedirect(success_url)
prefill=False
recipient_str=''
else:
if message_id :
# assuming this is a reply
parent = Message.objects.get(id=message_id)
form = form_class({
'body': _(u"%(sender)s wrote:\n%(body)s") % {
'sender': parent.sender,
'body': format_quote(parent.body)
},
'subject': _(u"Re: %(subject)s") % {'subject': parent.subject},
'recipient': [parent.sender,]
})
prefill = True
recipient_str = '%s %s (%s)'% (parent.sender.first_name, parent.sender.last_name, parent.sender.username)
else :
form = form_class()
if recipient is not None:
recipients = [u for u in User.objects.filter(username__in=[r.strip() for r in recipient.split('+')])]
form.fields['recipient'].initial = recipients
prefill = True
recipient_str = ','.join(['%s %s (%s)'%(u.first_name, u.last_name, u.username) for u in recipients])
else :
prefill = False
recipient_str = ''
return render_to_response(template_name, {
'form': form,
'prefill':prefill,
'recipient_str': recipient_str,
'inbox': Message.objects.inbox_for(request.user),
'outbox': Message.objects.outbox_for(request.user),
'trash' : Message.objects.trash_for(request.user),
'system_messages' : system_messages,
}, context_instance=RequestContext(request))
context.update({'common_language': common_language })
if request.method == 'POST':
letter_form = forms.LetterForm(sender_player, recipient_player, data=request.POST)
if letter_form.is_valid():
letter = letter_form.save()
messages.success(request, _("The letter has been successfully sent."))
## check if sender must be excommunicated
if not sender_player.is_excommunicated and recipient_player.is_excommunicated:
sender_player.set_excommunication(by_pope=False)
messages.info(request, _("You have been excommunicated."))
return redirect(game)
else:
if parent:
initial = {'body': _(u"%(sender)s wrote:\n%(body)s") % {
'sender': parent.sender_player.country,
'body': format_quote(parent.body)},
'subject': _(u"Re: %(subject)s") % {'subject': parent.subject},
}
else:
initial = {}
letter_form = forms.LetterForm(sender_player,
recipient_player,
initial=initial)
if not sender_player.is_excommunicated and recipient_player.is_excommunicated:
context['excom_notice'] = True
if sender_player.is_excommunicated and not recipient_player.is_excommunicated:
messages.error(request, _("You can write letters only to other excommunicated countries."))
return redirect(game)
context.update({'form': letter_form,
'sender_player': sender_player,
if not sender_player.is_excommunicated and \
r.is_excommunicated:
excom = True
messages.success(request, _("The letter has been successfully sent."))
## check if sender must be excommunicated
if not sender_player.is_excommunicated and \
recipient_player.is_excommunicated:
excom = True
if excom:
sender_player.set_excommunication(by_pope=False)
messages.info(request, _("You have been excommunicated."))
return redirect(game)
else:
if parent:
initial = {'body': unicode(format_quote(parent.body)),
'subject': _(u"Re: %(subject)s") % {'subject': parent.subject},
}
else:
initial = {}
letter_form = LetterForm(sender_player,
recipient_player,
initial=initial)
if not sender_player.is_excommunicated and recipient_player.is_excommunicated:
context['excom_notice'] = True
if sender_player.is_excommunicated and not recipient_player.is_excommunicated:
messages.error(request, _("You can write letters only to other excommunicated countries."))
return redirect(game)
context.update({'form': letter_form,
'sender_player': sender_player,
def in_out_trash_comp(request,
recipient=None,
message_id=None,
form_class=ComposeForm,
template_name='messages/messages.html',
success_url=None):
"""
combines inbox, outbox, trash and compose
"""
system_messages = []
for ms in request.user.message_set.all():
system_messages.append(ms)
if request.method == "POST":
sender = request.user
form = form_class(request.POST)
if form.is_valid():
form.save(sender=request.user)
request.user.message_set.create(
message=_(u"Message successfully sent."))
if success_url is None:
success_url = reverse('messages_all') + '#tabview=inbox'
return HttpResponseRedirect(success_url)
prefill = False
recipient_str = ''
else:
if message_id:
# assuming this is a reply
parent = Message.objects.get(id=message_id)
form = form_class({
'body': _(u"%(sender)s wrote:\n%(body)s") % {
'sender': parent.sender,
'body': format_quote(parent.body)
},
'subject': _(u"Re: %(subject)s") % {
'subject': parent.subject
},
'recipient': [
parent.sender,
]
})
prefill = True
recipient_str = '%s %s (%s)' % (parent.sender.first_name,
parent.sender.last_name,
parent.sender.username)
else:
form = form_class()
if recipient is not None:
recipients = [
u for u in User.objects.filter(
username__in=[r.strip() for r in recipient.split('+')])
]
form.fields['recipient'].initial = recipients
prefill = True
recipient_str = ','.join([
'%s %s (%s)' % (u.first_name, u.last_name, u.username)
for u in recipients
])
else:
prefill = False
recipient_str = ''
return render_to_response(
template_name, {
'form': form,
'prefill': prefill,
'recipient_str': recipient_str,
'inbox': Message.objects.inbox_for(request.user),
'outbox': Message.objects.outbox_for(request.user),
'trash': Message.objects.trash_for(request.user),
'system_messages': system_messages,
},
context_instance=RequestContext(request))
