def view_message(request, pk):
profile = request.user.get_profile()
messages = Message.objects.filter(thread=pk)
if (messages[0].to == profile) or (messages[0].author == profile):
if request.POST:
form = MessageForm(request.POST)
if form.is_valid():
form.save(commit=False)
f = form
f.author = profile
f.save()
else:
print form.errors
message_list = Message.objects.filter(thread=pk).order_by("-date_created")
message_form = MessageForm()
return render_to_response(
"publication/message_thread.html",
{"message_list": message_list, "message_form": message_form, "profile": profile},
context_instance=RequestContext(request),
)
else:
return HttpResponseRedirect("/messages/")
def moderation_object(request, message_id):
messages = []
message = get_object_or_404(Message, id=message_id, point__isnull=False)
if not message.point.location.admins.filter(id=request.user.id).count():
return HttpResponseNotFound()
form = None
if request.method == "POST":
if message.app.uid != 'webclient':
mform = MessageForm(request.POST, instance=message)
else:
mform = None
if message.point:
form = BasePointForm(request.POST, instance=message.point, prefix="point")
else:
if message.app.uid != 'webclient':
mform = MessageForm(instance=message)
else:
mform = None
if message.point:
form = BasePointForm(instance=message.point, prefix="point")
if request.method == "POST":
if all([mform is None or mform.is_valid(), form.is_valid()]):
if mform is not None:
mform.save()
form.save()
messages.append(u'Изменения успешно сохранены')
return render_to_response('manager_moderation_obj.html',
{'obj': message,
'info': {'messages': messages},
'mform': mform,
'form': form
},
RequestContext(request))
def chat(request, username):
"""Chat page."""
try:
# adressee. do not allow user to chat with himself.
user = User.objects.get(pk__ne=request.user.pk, username=username)
except (DoesNotExist, MultipleObjectsReturned):
raise Http404
all_messages = Message.objects.filter(
Q(author=request.user, addressee=user)
| Q(author=user, addressee=request.user)).order_by("created")
# Mark unread messages as read.
all_messages.filter(author=user, read=False).update(set__read=True)
if request.method == "POST":
form = MessageForm(request.POST)
if form.is_valid():
message = form.save(commit=False)
message.author = request.user
message.addressee = user
message.save()
return redirect("chat", user.username)
else:
form = MessageForm()
return render(request, 'chat.html', {
"addressee": user,
"form": form,
"all_messages": all_messages
})
def reply(request, topic):
if request.method == "POST":
message_form = MessageForm(request.POST, instance=Message())
topic = Topic.objects.get(slug=topic)
if message_form.is_valid():
message = message_form.save(commit=False)
message.category = topic.forum.category
message.topic = topic
message.forum = topic.forum
message.user = request.user
message.save()
action.send(request.user, verb='replied to', target=message.topic)
message.topic.responded_to = datetime.datetime.now()
message.topic.save()
Topic.objects.filter(id=topic.id).update(reply_count=F('reply_count')+1)
return HttpResponseRedirect(reverse('djero.views.topic', kwargs={
'category' : topic.forum.category.slug,
'forum' : topic.forum.slug,
'topic' : topic.slug
}))
else:
return HttpResponse("Invalid")
else:
message_form = MessageForm()
topic = get_object_or_404(Topic, slug=topic)
return render(request, "forum/reply.html", {
"message_form" : message_form,
"topic" : topic,
})
def inbox(request):
if request.method == "POST":
form = MessageForm(request.POST)
if form.is_valid():
to_user = form.cleaned_data['to']
subject = form.cleaned_data['subject']
message = form.cleaned_data['message']
to_user = User.objects.get(username=to_user)
Message.objects.create_message(request.user, to_user, subject,
message)
return HttpResponseRedirect("/message/inbox")
messages = Message.objects.get_all(request.user)
form = MessageForm()
unread_message_count = Message.objects.count_unread(request.user)
return render_to_response(
"message/inbox.html", {
'title': 'Message',
'messages': messages,
'form': form,
'user': request.user,
'unread': unread_message_count
})
def message(request):
if request.method == 'POST':
form = MessageForm(request.POST)
if form.is_valid():
name = form.cleaned_data['name']
content = form.cleaned_data['content']
ip = request.META['REMOTE_ADDR']
sess = request.session
if not sess.has_key( 'name' ) or sess['name'] != name:
sess['name'] = name
if name.lower() == 'orange':
name = 'Wrong way'
content = 'Try to pwn a shell instead of cracking md5.'
elif md5.new(name).hexdigest() == 'e5bc16fcbca0f279df17b66d8c37e109':
name = 'Orange'
Messages( name=name,
content=content,
ip=ip ).save()
return HttpResponseRedirect( '/' )
else:
sess = request.session.load()
if sess.has_key( 'name' ):
default = sess['name']
else:
default = 'Guest'
form = MessageForm( initial={'name': default} )
messages = Messages.objects.order_by('id').reverse()[:100]
response = render_to_response( 'message.html',
{'form': form, 'messages': messages} )
return response
def message(request):
if request.method == 'POST':
form = MessageForm(request.POST)
if form.is_valid():
name = form.cleaned_data['name']
email = form.cleaned_data['email']
homepage = form.cleaned_data['homepage']
title = form.cleaned_data['title']
content = form.cleaned_data['content']
ip = request.META['REMOTE_ADDR']
m = Message(name=name,
email=email,
homepage=homepage,
title=title,
content=content,
ip=ip)
m.save()
return HttpResponseRedirect('/message/')
else:
form = MessageForm()
messages = Message.objects.all().order_by('-time')
return render_to_response('message.html', {
'form': form,
'messages': messages
})
def create_message(request, recipient_id=None):
"""
Create a new message
"""
if request.method == 'POST':
form = MessageForm(request.POST, request.FILES, user=request.user)
if form.is_valid():
message = form.save(commit=False)
message.author = request.user
message.sent_at = datetime.now()
message.save()
for ban in message.recipient.get_profile().is_banned():
ban.end_time = datetime.now()
ban.save()
return redirect(reverse("private_messages_inbox"))
else:
if recipient_id:
user = User.objects.get(pk=recipient_id)
form = MessageForm(user=request.user, initial={'recipient': user})
else:
form = MessageForm(user=request.user)
return render_to_response("private_messages/message_new.html",
{"form": form}, context_instance=RequestContext(request))
def submit_ticket(request):
if request.user.is_authenticated():
ticket_form = TicketAuthenticatedUserForm(request.POST or None)
else:
ticket_form = TicketAnonymousUserForm(request.POST or None)
message_form = MessageForm(request.POST or None)
ticket_status_form = TicketStatusForm(request.POST or None)
context = {
"ticket_form": ticket_form,
"message_form": message_form,
"ticket_status_form": ticket_status_form
}
if request.POST:
if ticket_form.is_valid() and message_form.is_valid():
ticket = ticket_form.save(commit=False)
if request.user.is_authenticated():
ticket.submitter_email = request.user.email
ticket.submitter = request.user
ticket.save()
message = message_form.save(commit=False)
message.ticket = ticket
message.sender_type = 'U'
if request.user.is_authenticated():
message.sender = request.user
message.save()
return HttpResponse("Ticket Reference Number is: " + ticket.ref_no)
else:
return render(request, 'helpdesk/submit_ticket.html', context)
else:
return render(request, 'helpdesk/submit_ticket.html', context)
def show_ticket(request, ticket_uuid):
try:
ticket = Ticket.objects.get(uuid=ticket_uuid)
except:
return HttpResponse("Invalid Ticket")
message_form = MessageForm(request.POST or None)
if request.POST and message_form.is_valid():
message = message_form.save(commit=False)
message.ticket = ticket
if request.user.is_authenticated():
message.sender = request.user
message.sender_type = 'U'
message.save()
if (request.user.is_authenticated() and ticket.submitter
== request.user) or (not request.user.is_authenticated()
and ticket.submitter is None):
messages = ticket.message_set.order_by('create_time')
context = {
"ticket": ticket,
"message_form": message_form,
"messages": messages
}
return render(request, 'helpdesk/view_ticket.html', context)
else:
return HttpResponse("Invalid Ticket")
def staff_ticket_view(request, ticket_uuid):
try:
ticket = Ticket.objects.get(uuid=ticket_uuid)
except:
return HttpResponse("Invalid Ticket")
message_form = MessageForm(request.POST or None)
if request.POST and message_form.is_valid():
message = message_form.save(commit=False)
message.ticket = ticket
message.sender = request.user
message.sender_type = 'A'
message.save()
ticket_status_form = TicketAdminForm(request.POST or None, instance=ticket)
if request.POST and ticket_status_form.is_valid():
ticket_status_form.save()
return redirect('/helpdesk/admin/')
messages = ticket.message_set.order_by('create_time')
context = {
"ticket": ticket,
"message_form": message_form,
"messages": messages,
"ticket_status_form": ticket_status_form
}
return render(request, 'helpdesk/staff_ticket_view.html', context)
def view_message(request, pk):
profile=request.user.get_profile()
messages = Message.objects.filter(thread=pk)
if ((messages[0].to == profile) or (messages[0].author == profile)):
if request.POST:
form = MessageForm(request.POST)
if form.is_valid():
form.save(commit=False)
f = form
f.author = profile
f.save()
else:
print form.errors
message_list = Message.objects.filter(thread=pk).order_by('-date_created')
message_form = MessageForm()
return render_to_response('publication/message_thread.html', {
'message_list': message_list,
'message_form': message_form,
'profile':profile,
}, context_instance=RequestContext(request))
else:
return HttpResponseRedirect('/messages/')
def submit(request):
"""
returns a message submission page
processes a message submission
"""
# Process message form if it has been submitted
if request.method == 'POST':
message_form = MessageForm(request.POST)
recipient_form = RecipientForm(request.POST)
attachment_form = AttachmentForm(request.POST, request.FILES)
# Enter into database and email users if valid
if (message_form.is_valid() and
recipient_form.is_valid() and
attachment_form.is_valid()):
message = message_form.save()
attachment_form.save(message)
recipient_form.save(message)
return render_to_response('thanks.html')
# If message has not submitted, render message form
else:
message_form = MessageForm()
recipient_form = RecipientForm()
attachment_form = AttachmentForm()
return render(request, "submit.html",
{
"formset": message_form,
"recipients": recipient_form,
"attachments": attachment_form
})
def logged_in(request, username):
user = get_object_or_404(User, username=username)
if request.method == 'POST':
form = MessageForm(request.POST)
if form.is_valid():
Message.objects.create(
user=user,
msg=form.cleaned_data['msg'],
)
return HttpResponseRedirect('?')
else:
form = MessageForm()
# Use SQL to get the Message objects out via JOIN and DISTINCT
msgs = Message.objects.filter(
Q(user=user) | Q(user__following__dst=user)
).distinct()
# Alternatively, use .as_model() to get the User objects out
msgs = Tree('messages-for-%s' % user).values().as_model(Message)
return render_to_response('logged_in.html', {
'user': user,
'form': form,
'msgs': Paginator(msgs, 10).page(request.GET.get('page', 1)),
}, context_instance=RequestContext(request))
def msq_query(request, id):
c = {}
group_info = get_group(request.session['token'], id)
c['member_map'] = {member[u'user_id']: member[u'nickname'] for member in group_info[u'members']}
form = MessageForm(request.GET, created=group_info['created_at'], members=c['member_map'])
if form.is_valid():
d = form.cleaned_data
c['messages'] = Message.objects.filter(group=id, created__lte=d['end_date'],
created__gte=d['start_date'],
n_likes__gte=d['min_likes'],
n_likes__lte=d['max_likes'],
author__in=d['sent_by'],
text__icontains=d['text_contains'])
if d['text_not_contain']:
c['messages'] = c['messages'].exclude(text__icontains=d['text_not_contain'])
if d['img']:
c['messages'] = c['messages'].exclude(img__isnull=True)
if d['random']:
c['messages'] = list(c['messages'])
random.shuffle(c['messages'])
c['messages'] = c['messages'][:int(d['limit'])]
else:
sort = '-' + d['sort_by'] if d['sort_order'] else d['sort_by']
sort = (sort, '-created') if d['sort_by'] == 'n_likes' else (sort, '-n_likes')
c['messages'] = c['messages'].order_by(sort[0], sort[1])[:int(d['limit'])]
return render(request, 'message_table.html', c)
else:
return HttpResponse("");
def create_message(request, recipient_id=None):
"""
Create a new message
"""
if request.method == 'POST':
form = MessageForm(request.POST, request.FILES, user=request.user)
if form.is_valid():
message = form.save(commit=False)
message.author = request.user
message.sent_at = datetime.now()
message.save()
for ban in message.recipient.get_profile().is_banned():
ban.end_time = datetime.now()
ban.save()
return redirect(reverse("private_messages_inbox"))
else:
if recipient_id:
user = User.objects.get(pk=recipient_id)
form = MessageForm(user=request.user, initial={'recipient': user})
else:
form = MessageForm(user=request.user)
return render_to_response("private_messages/message_new.html",
{"form": form},
context_instance=RequestContext(request))
def group_info(request, group_id):
if request.method == 'POST':
form = MessageForm(request.POST)
if form.is_valid():
msg = form.cleaned_data['message']
message = GroupMessage()
message.group_id = group_id
message.from_email = request.user.username
message.message = msg
message.save()
# send signal
grpmsg_added.send(sender=GroupMessage, group_id=group_id,
from_email=request.user.username)
# Always return an HttpResponseRedirect after successfully dealing
# with POST data.
return HttpResponseRedirect(reverse('group_info', args=[group_id]))
else:
form = MessageForm()
op = request.GET.get('op', '')
if op == 'delete':
return group_remove(request, group_id)
elif op == 'dismiss':
return group_dismiss(request, group_id)
elif op == 'quit':
return group_quit(request, group_id)
return render_group_info(request, group_id, form)
def send_message(request):
"""
Render page where students / instructors can go to send a message to other users
"""
if request.method == "POST":
form = MessageForm(request.POST)
if form.is_valid():
try:
sender = request.user
recipient = User.objects.get(email=form.cleaned_data["recipient"])
subject = form.cleaned_data["subject"]
text = form.cleaned_data["text"]
new_message = Message(sender=sender,
recipient=recipient,
subject=subject,
text=text)
new_message.save()
except KeyError: #TODO Is this the right error?
# TODO indicate that recipient does not exist
pass
else:
# TODO indicate some kind of failure
pass
form = MessageForm()
context = {
"form": form,
}
return render(request, "sendmessage.html", context)
def post(self, request):
message_form = MessageForm(request.POST)
if message_form.is_valid():
message_form.save()
msg = u'修改成功'
else:
msg = message_form.errors
return render(request, 'index.html', {"response": msg})
def busi_cooper_page(request):
if request.method == 'POST':
msgform = MessageForm(request.POST);
if msgform.is_valid():
ctrls.saveMessageByForm(request,msgform);
return HttpResponseRedirect("/busi_cooper/")
else:
return render_to_response('businesscooper.html',context_instance=RequestContext(request))
def message_create(request):
if request.method == "POST":
form = MessageForm(request.POST)
if form.is_valid():
# TODO: content_object
msg = Message(msg=form.cleaned_data["msg"], user=request.user)
msg.save()
return HttpResponseRedirect("/")
def messaging_compose(request, response_format='html'):
"New message page"
user = request.user.profile
if request.POST:
if 'cancel' not in request.POST:
message = Message()
message.author = user.get_contact()
if not message.author:
return user_denied(request,
message="You can't send message without a Contact Card assigned to you.",
response_format=response_format)
form = MessageForm(
request.user.profile, None, None, request.POST, instance=message)
if form.is_valid():
message = form.save()
message.recipients.add(user.get_contact())
message.set_user_from_request(request)
message.read_by.add(user)
try:
# if email entered create contact and add to recipients
if 'multicomplete_recipients' in request.POST and request.POST['multicomplete_recipients']:
try:
conf = ModuleSetting.get_for_module(
'anaf.messaging', 'default_contact_type')[0]
default_contact_type = ContactType.objects.get(
pk=long(conf.value))
except Exception:
default_contact_type = None
emails = request.POST[
'multicomplete_recipients'].split(',')
for email in emails:
emailstr = unicode(email).strip()
if re.match('[a-zA-Z0-9+_\-\.]+@[0-9a-zA-Z][.-0-9a-zA-Z]*.[a-zA-Z]+', emailstr):
contact, created = Contact.get_or_create_by_email(
emailstr, contact_type=default_contact_type)
message.recipients.add(contact)
if created:
contact.set_user_from_request(request)
except:
pass
# send email to all recipients
message.send_email()
return HttpResponseRedirect(reverse('messaging'))
else:
return HttpResponseRedirect(reverse('messaging'))
else:
form = MessageForm(request.user.profile, None)
context = _get_default_context(request)
context.update({'form': form})
return render_to_response('messaging/message_compose', context,
context_instance=RequestContext(request), response_format=response_format)
def detail(request, pk):
"""
View a buddy profile
"""
buddy = get_object_or_404(Buddy, pk=pk)
# if not viewing own profile, restrict to organisations
try:
request.user.buddy.get(pk=pk)
except Buddy.DoesNotExist:
try:
organisation = request.user.organisation.all()[0]
except IndexError:
return HttpResponseForbidden()
try:
organisation = request.user.organisation.all()[0]
except IndexError:
organisation = None
if organisation:
message_form = MessageForm(request.POST or None,
initial={
'message':
'''Dear <name>,
Would you like to help out doing .......
If you are able to help, you would need to be able to ....
Please reply with your email address and phone number so that we can get in touch with you.
Kind regards,
<name>'''
})
if message_form.is_valid():
contact = ContactLog(
**{
'service': organisation,
'buddy': buddy,
'message': message_form.cleaned_data['message']
})
contact.save()
subject = 'You have a new message from refugeebuddy.org'
message = render_to_string('buddies/email/buddy_message.txt',
{'contact': contact})
send_mail(subject, message, settings.DEFAULT_FROM_EMAIL,
[buddy.email])
messages.success(request, 'Your message has been sent')
return redirect('.')
else:
message_form = None
return render_to_response('buddies/detail.html', {
'buddy': buddy,
'message_form': message_form
},
context_instance=RequestContext(request))
def save_message(request):
if request.method == "POST":
form = MessageForm(request.user, data=request.POST)
if form.is_valid():
form.save()
else:
return render(request, "message_board/new_message.html",
{"new_msg_form": form})
return redirect("home")
def message_create(request):
if request.method == "POST" and request.is_ajax():
form = MessageForm(request.POST)
if form.is_valid():
msg = Message(msg=form.cleaned_data["msg"], user=request.user)
msg.save()
return render(request, "social/message_form_popup_response.html",
{'response': _("Your message has been successfully posted"),
'object': msg,
})
else:
return HttpResponse("sonaste")
elif request.method == "POST":
form = MessageForm(request.POST)
if form.is_valid():
msg = Message(msg=form.cleaned_data["msg"], user=request.user)
msg.save()
return HttpResponseRedirect(request.META.get('HTTP_REFERER', '/'))
def busi_cooper_page(request):
if request.method == 'POST':
msgform = MessageForm(request.POST)
if msgform.is_valid():
ctrls.saveMessageByForm(request, msgform)
return HttpResponseRedirect("/busi_cooper/")
else:
return render_to_response('businesscooper.html',
context_instance=RequestContext(request))
def message_to_user(request):
if request.method == "POST":
form = MessageForm(request, data=request.POST)
if form.is_valid():
# do something with the form
return redirect("message_to_user_done")
else:
form = MessageForm(request)
return render(request, "message_to_user.html", {'form': form})
def message_create(request):
if request.method == "POST" and request.is_ajax():
form = MessageForm(request.POST)
if form.is_valid():
msg = Message(msg=form.cleaned_data["msg"], user=request.user)
msg.save()
return render(
request, "social/message_form_popup_response.html", {
'response': _("Your message has been successfully posted"),
'object': msg,
})
else:
return HttpResponse("sonaste")
elif request.method == "POST":
form = MessageForm(request.POST)
if form.is_valid():
msg = Message(msg=form.cleaned_data["msg"], user=request.user)
msg.save()
return HttpResponseRedirect(request.META.get('HTTP_REFERER', '/'))
def send(request):
if request.method == 'POST':
form = MessageForm(request.POST)
if form.is_valid():
send_message(from_user=request.user, form=form)
return redirect('/message/sended')
else:
form = MessageForm()
return render_to_response('message/send.html', {'form': form},
context_instance=RequestContext(request))
def message(request, event_id, type):
event = get_object_or_404(Event, id=event_id)
form = MessageForm(user=request.user, event=event, type=type, data=(request.POST or None),
initial={"guests": request.GET.get("guests", "").split(",")})
if form.is_valid():
form.save()
messages.success(request, "Your message has been sent.")
return redirect(event)
template = "events/message.html"
return render_to_response(template, locals(), context_instance=RequestContext(request))
def sendmessage(request):
basic = get_basic(request)
message_sent = False
try:
user = User.objects.get(id=request.GET['id'])
except User.DoesNotExist:
return HttpResponseRedirect('/messages')
if request.method == 'POST':
form = MessageForm(request.POST)
if form.is_valid():
obj = form.save(commit=False)
obj.from_user = request.user
obj.to_user = user
obj.save()
try:
to_prof = Profile.objects.get(user=user)
except Profile.DoesNotExist:
to_prof = Profile()
if to_prof.message_email:
try:
from_prof = Profile.objects.get(user=request.user)
except Profile.DoesNotExist:
from_prof = Profile()
if from_prof.first_name:
from_name = from_prof.first_name
if from_prof.last_name:
from_name = " ".join([from_name, from_prof.last_name])
else:
from_name = request.user.username
if to_prof.first_name:
to_name = to_prof.first_name
else:
to_name = user.username
title = "CreationDex - New Message from " + from_name
msg_url = "https://creationdex.com/viewmessage?id=" + str(obj.id)
from_url = "https://creationdex.com/profile?id=" + str(request.user.id)
options_url = "https://creationdex.com/accounts/options/"
plain_content = ("Hello, " + to_name + ".\n\n" + from_name +
" has sent you a new message. Go to " + msg_url + " to read it" +
" at creationdex.com, or go to " + options_url + " to change" +
" your email options.\n\n Preview: \"" + obj.content + "\"")
html_content = ("<p>Hello, " + to_name + ".</p><p><a href=\"" +
from_url + "\">" + from_name + "</a>" +
" has sent you a new message. Click <a href=\"" + msg_url +
"\">here</a>" + " to read it at creationdex.com, or click" +
" <a href=\"" + options_url + "\">here</a> to change your" +
" email options.</p>" +
"<p>Preview: \"" + obj.content + "\"</p>")
send_mail(title, plain_content, settings.EMAIL_HOST_USER, [user.email],
fail_silently=True, html_message=html_content)
return HttpResponseRedirect('/messages/')
else:
form = MessageForm()
return render(request, 'sendmessage.html', {'form': form, 'basic': basic,
'user': user })
def contact_form_process(request):
contact_form_done = False
message_form = MessageForm(request.POST or None, prefix="message")
if message_form.is_valid():
obj = message_form.save()
d = {"text": obj.text, "name": obj.name, "phone": obj.phone, "email": obj.email, "subject": obj.subject, }
Email.objects.get(id_name="message").send(settings.NOTIFY_MAIL, d, obj.email)
contact_form_done = True
message_form = None
# return HttpResponseRedirect("/")
return contact_form_done, message_form
def post_message(request, event_id):
if request.method == "POST":
form = MessageForm(request.POST)
if form.is_valid():
event = get_object_or_404(Event, pk=event_id)
message = form.cleaned_data['message']
user = request.user
message_obj = Message.objects.create(event=event, datetime=datetime.now(), user=user, message=message)
return HttpResponseRedirect(reverse("view_event", args=[event_id]))
else:
return HttpResponse(form.errors)
def send_message(request):
if request.method != 'POST':
return HttpResponseNotFound()
form = MessageForm(request.POST)
other_user = form['recip']
if form.is_valid():
cd = form.cleaned_data
m = Message(sender=request.user, recip=cd['recip'], subject=cd['subject'], content=cd['content'], thread_id=cd['thread_id'])
m.save()
return HttpResponseRedirect(reverse('inbox'))
return HttpResponse('There was an error with your message')
def new_message(request):
if request.method == 'POST':
form = MessageForm(request.POST)
if form.is_valid():
newMessage = Message()
save_message_from_form(newMessage, form)
return HttpResponseRedirect('/sms/messages')
else:
form = MessageForm()
return render_to_response('sms/new_message.html',
{'form': form },
context_instance=RequestContext(request))
def add_message(request, page_number=1):
messages = Message.objects.filter(date_published__lte=timezone.now()).order_by('-date_published')
current_page = Paginator(messages, 5)
form = MessageForm(request.POST or None)
if request.user.is_authenticated():
if form.is_valid():
message = form.save(commit=False)
message.mes_user=request.user
message.date_published=datetime.datetime.now()
message.save()
return redirect("/")
return render_to_response('message.html', {'form': form, 'messages': current_page.page(page_number), 'username': auth.get_user(request).username}, RequestContext(request))
def post_message(request):
logger.debug("Entering post message")
c = {}
c.update(csrf(request))
if request.POST:
form = MessageForm(request.POST)
if form.is_valid():
form.save()
logger.debug("Exiting post message")
return render_to_response('index.html', c)
def post_message(request):
if request.method == 'POST':
form = MessageForm(request.POST, request.FILES)
print request.POST
if form.is_valid():
form.save()
print "save ok"
return HttpResponseRedirect('/success/')
else:
form = MessageForm()
return render_to_response('messages/upload.html', {'form': form})
def send_message(request):
if request.method == 'POST':
form = MessageForm(request.POST)
if form.is_valid():
cd = form.cleaned_data
statement = 'Pomyślnie wysłano wiadomość.'
form.save()
return render(request, 'contact/success.html',
{'statement': statement})
else:
form = MessageForm()
return render(request, 'contact/contact.html', {'form': form})
def save_message(request):
if request.method == 'POST':
form = MessageForm(request.POST)
if form.is_valid():
newMessage = Message.objects.get(pk=form.cleaned_data['id'])
save_message_from_form(newMessage, form)
return HttpResponseRedirect('/sms/messages')
else:
form = MessageForm()
return render_to_response('sms/edit_message.html',
{'form': form },
context_instance=RequestContext(request))
def guestbook(request):
messages = Message.objects.all().order_by('-date')
if request.method == 'POST':
name = request.POST.get('name', None)
message = request.POST.get('message', None)
spam = request.POST.get('spam_catcher', None)
if spam or 'href' in message or 'http' in message or '<a' in message:
return redirect('http://www.law.cornell.edu/wex/inbox/state_anti-spam_laws')
form = MessageForm(request.POST)
if form.is_valid():
if not Message.objects.filter(name=name, message=message):
#prevents duplicate entries
message = form.save()
return render_to_response("guestbook.html", {'messages':messages}, RequestContext(request))
def send_msg(request):
if request.POST:
form = MessageForm(request.POST)
if form.is_valid():
sender = form.cleaned_data["sender"]
text = form.cleaned_data["text"]
new_msg = Message(sender=sender, text=text)
new_msg.save()
json = simplejson.dumps({"sender": new_msg.sender, "text": new_msg.text, "date": str(new_msg.date)})
return HttpResponse(json, content_type="application/json")
def index_view(request, template="bmxacademy/index.html"):
if show_intro(request):
return HttpResponseRedirect("/intro/")
new_qs = New.objects.order_by("-pk")
video_qs = Video.objects.order_by("-pk")
gallery_qs = Gallery.objects.order_by("-pk")
registration_form_done = False
message_form_done = False
registration_form = RegistrationForm(request.POST or None, prefix="registration")
if registration_form.is_valid():
obj = registration_form.save()
d = { "name": obj.name, "email": obj.email, "phone": obj.phone, }
Email.objects.get(id_name="registration").send(settings.NOTIFY_MAIL, d)
Email.objects.get(id_name="registration_participant").send(obj.email, d)
registration_form_done = True
# return HttpResponseRedirect("/")
message_form = MessageForm(request.POST or None, prefix="message")
if message_form.is_valid():
obj = message_form.save()
d = {"text": obj.text, "name": obj.name, "phone": obj.phone, "email": obj.email, "subject": obj.subject, }
Email.objects.get(id_name="message").send(settings.NOTIFY_MAIL, d, obj.email)
message_form_done = True
# return HttpResponseRedirect("/")
if not request.POST:
registration_form = None
message_form = None
else:
if request.POST["form"] == "message":
registration_form = None
if request.POST["form"] == "registration":
message_form = None
a = gallery_qs[0].picture_set.order_by("order")[:300]
gallery = [a[i:i+12] for i in range(0,len(a),12)]
return render_to_response(template,
{
"new_qs": new_qs,
"video_qs": video_qs,
"registration_form": registration_form,
"message_form": message_form,
"gallery_qs": gallery_qs,
"gallery": gallery,
"registration_form_done": registration_form_done,
"message_form_done": message_form_done,
},
context_instance=RequestContext(request))
def mlist_view(request, mlist_id, response_format='html'):
"Mailing List view page"
user = request.user.profile
mlist = get_object_or_404(MailingList, pk=mlist_id)
if not request.user.profile.has_permission(mlist):
return user_denied(
request,
message="You don't have access to this Mailing List",
response_format=response_format)
if request.user.profile.has_permission(mlist, mode='x'):
if request.POST:
message = Message()
message.author = request.user.profile.get_contact()
if not message.author:
return user_denied(
request,
message=
"You can't send message without a Contact Card assigned to you.",
response_format=response_format)
form = MessageForm(request.user.profile,
mlist_id,
None,
request.POST,
instance=message)
if form.is_valid():
message = form.save()
message.set_user_from_request(request)
message.read_by.add(user)
return HttpResponseRedirect(
reverse('messaging_mlist_view', args=[mlist.id]))
else:
form = MessageForm(request.user.profile, mlist_id)
else:
form = None
messages = Object.filter_by_request(
request,
Message.objects.filter(reply_to__isnull=True,
mlist=mlist).order_by('-date_created'))
context = _get_default_context(request)
context.update({'messages': messages, 'form': form, 'mlist': mlist})
return render_to_response('messaging/mlist_view',
context,
context_instance=RequestContext(request),
response_format=response_format)
def chat(request, id):
bribe = get_object_or_404(Bribe, id=id)
form = MessageForm(request.POST or None)
if form.is_valid():
new_message = form.save(commit=False)
new_message.bribe = bribe
new_message.user = request.user
new_message.save()
form = MessageForm()
return render_to_response('admin/chat.html', RequestContext(request, {'bribe': bribe, 'form': form}))
def add_message(request):
bribe = Bribe.objects.get(secure_token=request.GET['secure_token'])
form = MessageForm(request.POST or None)
if form.is_valid():
new_message = form.save(commit=False)
new_message.bribe = bribe
new_message.save()
form = MessageForm()
return HttpResponse(simplejson.dumps({'status' : 'ok' }), mimetype='application/json')
else:
return HttpResponseBadRequest()
def detail(request, pk):
"""
View a buddy profile
"""
buddy = get_object_or_404(Buddy, pk=pk)
# if not viewing own profile, restrict to organisations
try:
request.user.buddy.get(pk=pk)
except Buddy.DoesNotExist:
try:
organisation = request.user.organisation.all()[0]
except IndexError:
return HttpResponseForbidden()
try:
organisation = request.user.organisation.all()[0]
except IndexError:
organisation = None
if organisation:
message_form = MessageForm(request.POST or None, initial = {'message' : '''Dear <name>,
Would you like to help out doing .......
If you are able to help, you would need to be able to ....
Please reply with your email address and phone number so that we can get in touch with you.
Kind regards,
<name>'''})
if message_form.is_valid():
contact = ContactLog(**{
'service': organisation,
'buddy': buddy,
'message': message_form.cleaned_data['message']
})
contact.save()
subject = 'You have a new message from refugeebuddy.org'
message = render_to_string('buddies/email/buddy_message.txt', {'contact': contact})
send_mail(subject, message, settings.DEFAULT_FROM_EMAIL, [buddy.email])
messages.success(request, 'Your message has been sent')
return redirect('.')
else:
message_form = None
return render_to_response('buddies/detail.html', {
'buddy': buddy,
'message_form': message_form
}, context_instance=RequestContext(request))
def add_message(request):
if request.method == "POST":
message_form = MessageForm(request.POST or None)
if message_form.is_valid():
message_form.save()
return HttpResponseRedirect(request.session.get('real_url'))
else:
message_form = MessageForm()
context = {
"message_form": message_form,
}
return render(request, 'add_message.html', context)
def guestbook(request):
messages = Message.objects.all().order_by('-date')
if request.method == 'POST':
name = request.POST.get('name', None)
message = request.POST.get('message', None)
spam = request.POST.get('spam_catcher', None)
if spam or 'href' in message or 'http' in message or '<a' in message:
return redirect(
'http://www.law.cornell.edu/wex/inbox/state_anti-spam_laws')
form = MessageForm(request.POST)
if form.is_valid():
if not Message.objects.filter(name=name, message=message):
#prevents duplicate entries
message = form.save()
return render_to_response("guestbook.html", {'messages': messages},
RequestContext(request))
def create_message(request):
if request.method == 'POST':
if request.is_ajax():
new_message_form = MessageForm(request.POST)
if new_message_form.is_valid():
new_message = new_message_form.save(commit=False)
new_message.author = UserProfile.objects.get(
pk=request.user.userprofile.pk)
new_message.chat_room = ChatRoom.objects.get(
pk=request.POST['chat_id'])
if request.user.userprofile not in new_message.chat_room.users.all(
):
return redirect("/")
new_message.save()
return JsonResponse(request.POST)
return redirect("/")
def post(self, request, to=''):
form = MessageForm(request.POST)
if form.is_valid():
message = form.save(commit=False)
chain = Chain.objects.create()
chain.members.add(*form.cleaned_data['recipient'])
chain.members.add(self.user)
chain.have_read.add(self.user)
chain.save()
message.chain = chain
message.sender = self.user
message.save()
return self.to_inbox()
return self.get(request)
def new_message(request):
pass
if request.method == "POST":
message_form = MessageForm(request.POST, user=request.user)
messages = Message.objects.all().order_by('-create_date')
if message_form.is_valid() and request.POST.get('commit', ''):
post = message_form.save()
return HttpResponseRedirect(reverse("guestbook_index"))
return render_to_response("guestbook/index.html", {
"settings": settings,
"message_form": message_form,
"messages": messages,
}, RequestContext(request))
else:
return HttpResponseRedirect(reverse("guestbook_index"))
def student(request):
"""
Render the student homepage.
Gets a few projects to display as a sample, and any messages / notifications for the student
"""
try:
Section.objects.get(students__id=request.user.id)
except ObjectDoesNotExist:
return HttpResponseRedirect("/joinsection/")
if request.method == "POST":
form = MessageForm(request.POST)
if form.is_valid():
try:
sender = request.user
recipient = User.objects.get(email=form.cleaned_data["recipient"])
subject = form.cleaned_data["subject"]
text = form.cleaned_data["text"]
new_message = Message(sender=sender,
recipient=recipient,
subject=subject,
text=text)
new_message.save()
except KeyError: #TODO Is this the right error?
# TODO indicate that recipient does not exist
pass
else:
# TODO indicate some kind of failure
pass
projects = Project.objects.filter(is_approved=True)[:5] # This is efficient according to docs, although it doesn't look that way
personalMessages = Message.objects.filter(recipient__id=request.user.id)
notifications = reversed(Notification.objects.filter(recipient__id=request.user.id))
form = MessageForm()
context = {
"projects": projects,
"inbox": personalMessages,
"form": form,
"notifications": notifications
}
return render(request, "student.html", context)
def thread(request, **args):
t = loader.get_template('discussion.view')
thread = None
if 'id' in args:
thread = Thread.objects.get(id=int(args['id']))
message_form = None
if thread and thread.openForEvent():
if request.method == 'POST':
# Post dictionary needs to be mutable in order to remove the value from the messagebox
post_vars = {}
for key in request.POST:
post_vars[key] = request.POST[key]
message_form = MessageForm(post_vars)
if message_form.is_valid():
message = Message()
message.content = message_form.cleaned_data['content']
message_form.data['content'] = ''
message.time = datetime.now()
message.user = request.user
message.thread = thread
message.save()
else:
message_form = MessageForm()
c = {
'thread': thread,
'thread_message': thread.getStatusMessage(),
'thread_status': thread.getStatus(),
'messages': None,
'message_form': message_form,
'is_authenticated': request.user.is_authenticated()
}
if thread:
messages = Message.objects.filter(thread__id=thread.id)
c['messages'] = messages
c.update(csrf(request))
return HttpResponse(t.render(Context(c)))
def send_message(request, message_id):
"""
Render page where students / instructors can go to send a message to other users
"""
if (message_id != ''):
message = Message.objects.get(id=message_id)
form_init = {
'recipient': message.sender,
'subject': 'RE: ' + message.subject,
'text': message.reply_text
}
else:
form_init = {}
if request.method == "POST":
form = MessageForm(request.POST)
if form.is_valid():
sender = request.user
recipient = User.objects.get(email=form.data["recipient"])
subject = form.data["subject"]
text = form.data["text"].split('\n >')[0]
old_reply_text = message.reply_text if message_id != '' else ''
reply_text = '\n\n'
reply_lines = ('From: ' + sender.email + '\n' + text +
old_reply_text).split('\n')
for line in reply_lines:
reply_text = reply_text + ' > ' + line + '\n'
new_message = Message(sender=sender,
recipient=recipient,
subject=subject,
text=text,
reply_text=reply_text)
new_message.save()
return redirect_user_to_homepage(request.user.profile.user_type)
form = MessageForm(initial=form_init)
context = {
"form": form,
}
return render(request, "sendmessage.html", context)
def addMessage(request):
if request.method == 'POST':
messageForm = MessageForm(data=request.POST)
if messageForm.is_valid():
message = messageForm.save(commit=False)
message.poster = request.user
message.save()
return HttpResponseRedirect("/messages/")
else:
messageForm = MessageForm()
# Render the template depending on the context.
return render(
request,
'citadel/messagesAdd.html',
{
'add_msg': messageForm,
'is_logged_in': request.user.is_authenticated()
},
)
def send_message(request, username):
recipient = get_object_or_404(Patient, user__username=username).user
sender = request.user
if request.method == "POST":
form = MessageForm(request.POST)
if form.is_valid():
form.sender_id = sender
form.receiver_id = recipient
message = Message(sender=sender,
body=form.cleaned_data['body'],
receiver=recipient,
read_flag=False)
message.save()
return HttpResponseRedirect(
reverse('conversation',
kwargs={"sender_name": message.receiver.username}))
else:
form = MessageForm()
return TemplateResponse(request, 'send.html', {
"form": form,
"recipient": recipient
})
def message(request):
if request.method == "POST":
form = MessageForm(request.POST, error_class=DefinitionErrorList)
if form.is_valid():
try:
msg = form.save(commit=False)
msg.save()
message = render_to_string('message_email.txt', {'msg': msg})
send_to = [manager[1] for manager in settings.MANAGERS]
email = EmailMessage(u"Сообщение с сайта temp-msk", message,
u'ТЕМП <*****@*****.**>', send_to)
email.send()
messages.success(
request, u'Сообщение отправлено специалистам компании')
return {'form': MessageForm()}
except:
messages.error(
request,
u'При отправке произошла ошибка. Пожалуйста, повторите попытку позднее.'
)
else:
form = MessageForm()
return {'form': form}
