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 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 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 post(self):
abort_if_not_an_admin()
data = ImmutableMultiDict(request.json)
message_form = MessageForm(data, csrf_enabled=False)
if message_form.validate():
message_form.save()
return {"status": "success"}
return message_form.errors
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(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 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 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 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 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 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 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 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 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 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 post(self):
user_id = force_int(self.get_argument('user_id', 0), 0)
current_user = self.current_user
user = User.get(id=user_id)
if user:
form = MessageForm(self.request.arguments)
if form.validate():
message_box1 = current_user.get_message_box(user=user)
message_box2 = user.get_message_box(user=current_user)
if not message_box1:
message_box1 = MessageBox(sender_id=current_user.id,
receiver_id=user.id, status=1).save()
if not message_box2:
message_box2 = MessageBox(sender_id=user.id,
receiver_id=current_user.id).save()
message = form.save(user_id=current_user.id,
message_box1_id=message_box1.id,
message_box2_id=message_box2.id)
result = {"status": "success", "message": "私信发送成功",
"content": message.content, "created": message.created,
"avatar": current_user.get_avatar(size=48), "url":
current_user.url, "id": message.id}
else:
result = {"status": "error", "message": "请填写至少 4 字的内容"}
if self.is_ajax:
return self.write(result)
self.flash_message(result)
return self.redirect_next_url()
result = {"status": "error", "message": "没有目标用户，不能发送私信哦"}
if self.is_ajax:
return self.write(result)
self.flash_message(result)
return self.redirect_next_url()
def post(self):
user_id = force_int(self.get_argument('user_id', 0), 0)
sender = self.current_user
receiver = User.get(id=user_id)
if receiver:
form = MessageForm(self.request.arguments)
if form.validate():
message = form.save(sender_id=sender.id,
receiver_id=receiver.id)
result = {
"status": "success",
"message": "私信发送成功",
"content": message.content,
"created": message.created,
"avatar": sender.get_avatar(size=48),
"url": sender.url,
"id": message.id,
}
else:
result = {"status": "error", "message": "请填写至少 4 字的内容"}
self.send_result(result)
self.finish()
return WebSocketHandler.send_message(message.receiver_id, message)
result = {"status": "error", "message": "没有目标用户，不能发送私信哦"}
self.send_result(result)
def post(self):
user_id = force_int(self.get_argument('user_id', 0), 0)
sender = self.current_user
receiver = User.get(id=user_id)
if receiver:
form = MessageForm(self.request.arguments)
if form.validate():
message = form.save(sender_id=sender.id,
receiver_id=receiver.id)
result = {
"status": "success",
"message": "私信发送成功",
"content": message.content,
"created": message.created,
"avatar": sender.get_avatar(size=48),
"url": sender.url,
"id": message.id,
}
else:
result = {"status": "error", "message": "请填写至少 4 字的内容"}
self.send_result(result)
self.finish()
return WebSocketHandler.send_message(message.receiver_id, message)
result = {"status": "error", "message": "没有目标用户，不能发送私信哦"}
self.send_result(result)
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 create(request):
if request.POST:
form = MessageForm(request.POST)
if form.is_valid():
form.save()
return HttpResponseRedirect('/messages/all')
else:
form = MessageForm()
args = {}
args.update(csrf(request))
args['form'] = form
return render_to_response('create_message.html', args)
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 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 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 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 create_pm(request, id):
from forms import MessageForm
model = get_model('net', 'User')
data = {
'content_type': ContentType.objects.get_for_model(model).pk,
'object_id': id,
'parent': request.GET.get('parent'),
'private': request.GET.get('private'),
}
if request.POST:
form = MessageForm(data=request.POST, initials=data)
if form.is_valid():
form.save(request.user.user)
return HttpResponseRedirect(reverse('user_profile', args=[id]))
else:
form = MessageForm(initials=data)
return {
'form': form,
'object_id': id,
}
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 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 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 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 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 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 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 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 post(self):
user_id = force_int(self.get_argument('user_id', 0), 0)
sender = self.current_user
receiver = User.get(id=user_id)
if receiver:
form = MessageForm(self.request.arguments)
if form.validate():
"""
message_box1 = current_user.get_message_box(user=user)
message_box2 = user.get_message_box(user=current_user)
if not message_box1:
message_box1 = MessageBox(sender_id=current_user.id,
receiver_id=user.id, status=1).save()
if not message_box2:
message_box2 = MessageBox(sender_id=user.id,
receiver_id=current_user.id).save()
"""
message = form.save(sender_id=sender.id,
receiver_id=receiver.id)
result = {
"status": "success",
"message": "私信发送成功",
"content": message.content,
"created": message.created,
"avatar": sender.get_avatar(size=48),
"url": sender.url,
"id": message.id
}
else:
result = {"status": "error", "message": "请填写至少 4 字的内容"}
if self.is_ajax:
self.write(result)
else:
self.flash_message(result)
self.redirect_next_url()
self.finish()
WebSocketHandler.send_message(message.receiver_id, message)
return
result = {"status": "error", "message": "没有目标用户，不能发送私信哦"}
if self.is_ajax:
return self.write(result)
self.flash_message(result)
return self.redirect_next_url()
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}
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 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 message_create(request, user_id=None, message_id=None):
original_message = None
if message_id:
original_message = get_object_or_404(Message, pk=message_id, recipient=request.user)
initial = {'recipient': original_message.sender, 'title': "Re: %s" % original_message.title}
elif user_id:
initial = {'recipient': get_object_or_404(User, pk=user_id)}
else:
initial = None
form = MessageForm(data=request.POST or None, initial=initial)
if form.is_valid():
message = form.save(commit=False)
message.sender = request.user
message.in_reply_to = original_message
message.save()
messages.success(request, _('Message successfully sent'))
notify.message_received(message.recipient, message)
return HttpResponseRedirect(reverse('message_list_out'))
return render(request, 'message/create.html', {'form': form})
def create_topic(request, forum):
forum = Forum.objects.select_related('Moderator').get(slug=forum)
if request.method == "POST":
topic_form = TopicForm(request.POST, instance=Topic())
message_form = MessageForm(request.POST, instance=Message())
if topic_form.is_valid():
if message_form.is_valid():
topic = topic_form.save(commit=False)
topic.category = forum.category
topic.forum = forum
topic.user = request.user
topic.last_user = request.user
topic.save()
message = message_form.save(commit=False)
message.category = forum.category
message.forum = forum
message.topic = topic
message.user = request.user
message.save()
topic.message = message
topic.last_message = message
topic.save()
action.send(request.user, verb='created a topic', target=topic)
return HttpResponseRedirect(reverse('djero.views.topic', kwargs={
'category' : forum.category.slug,
'forum' : forum.slug,
'topic' : topic.slug,
}))
else:
return HttpResponse(topic_form.errors)
else:
topic_form = TopicForm()
message_form = MessageForm()
return render(request, "forum/create_topic.html", {
"forum" : forum,
"topic_form" : topic_form,
"message_form" : message_form,
})
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}
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 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 stream_view(request, stream_id, response_format='html'):
"Stream view page"
user = request.user.profile
stream = get_object_or_404(MessageStream, pk=stream_id)
if not request.user.profile.has_permission(stream):
return user_denied(request,
message="You don't have access to this Stream",
response_format=response_format)
if request.user.profile.has_permission(stream, mode='x'):
if 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_stream_view', args=[stream.id]))
else:
form = MessageForm(request.user.profile, stream_id)
else:
form = None
objects = Object.filter_by_request(
request,
Message.objects.filter(reply_to__isnull=True,
stream=stream).order_by('-date_created'))
context = _get_default_context(request)
context.update({'messages': objects, 'form': form, 'stream': stream})
return render_to_response('messaging/stream_view',
context,
context_instance=RequestContext(request),
response_format=response_format)
def stream_view(request, stream_id, response_format='html'):
"Stream view page"
user = request.user.profile
stream = get_object_or_404(MessageStream, pk=stream_id)
if not request.user.profile.has_permission(stream):
return user_denied(request, message="You don't have access to this Stream",
response_format=response_format)
if request.user.profile.has_permission(stream, mode='x'):
if 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_stream_view', args=[stream.id]))
else:
form = MessageForm(request.user.profile, stream_id)
else:
form = None
objects = Object.filter_by_request(request, Message.objects.filter(
reply_to__isnull=True, stream=stream).order_by('-date_created'))
context = _get_default_context(request)
context.update({'messages': objects,
'form': form,
'stream': stream})
return render_to_response('messaging/stream_view', context,
context_instance=RequestContext(request),
response_format=response_format)
def savemessage(request):
form = MessageForm(request.POST)
if form.is_valid():
entry = form.save()
return render(request, "messages.html", {"success": True})
