def clean(self, value):
super(CommaSeparatedUserField, self).clean(value)
if not value:
return ''
if isinstance(value, (list, tuple)):
return value
names = set(value.split(','))
names_set = set([name.strip() for name in names if name.strip()])
users = list(User.objects.filter(**{'%s__in' % get_username_field(): names_set}))
unknown_names = names_set ^ set([getattr(user, get_username_field()) for user in users])
recipient_filter = self._recipient_filter
sender = self._sender
invalid_users = []
if recipient_filter is not None:
for r in users:
if recipient_filter(r, sender) is False:
users.remove(r)
invalid_users.append(getattr(r, get_username_field()))
if unknown_names or invalid_users:
raise forms.ValidationError(_(u"The following usernames are incorrect: %(users)s") % {'users': ', '.join(list(unknown_names)+invalid_users)})
return users
def clean(self, value):
super(CommaSeparatedUserField, self).clean(value)
if not value:
return ''
if isinstance(value, (list, tuple)):
return value
names = set(value.split(','))
names_set = set([name.strip() for name in names if name.strip()])
users = list(
User.objects.filter(
**{'%s__in' % get_username_field(): names_set}))
unknown_names = names_set ^ set(
[getattr(user, get_username_field()) for user in users])
recipient_filter = self._recipient_filter
invalid_users = []
if recipient_filter is not None:
for r in users:
if recipient_filter(r) is False:
users.remove(r)
invalid_users.append(getattr(r, get_username_field()))
if unknown_names or invalid_users:
raise forms.ValidationError(
_(u"The following usernames are incorrect: %(users)s") %
{'users': ', '.join(list(unknown_names) + invalid_users)})
return users
def _format_display(self, display):
User = get_user_model()
if not isinstance(display, User):
try:
display = User.objects.get(**{'%s__iexact' % get_username_field(): display})
except User.DoesNotExist:
return ""
if self.recipient_format:
return self.recipient_format(display)
return getattr(display, get_username_field())
def compose(request, recipient=None, form_class=ComposeForm,
template_name='django_messages/compose.html', success_url=None, recipient_filter=None):
"""
Displays and handles the ``form_class`` form to compose new messages.
Required Arguments: None
Optional Arguments:
``recipient``: username of a `django.contrib.auth` User, who should
receive the message, optionally multiple usernames
could be separated by a '+'
``form_class``: the form-class to use
``template_name``: the template to use
``success_url``: where to redirect after successfull submission
"""
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)
messages.info(request, _(u"Message successfully sent."))
if success_url is None:
success_url = reverse('messages_inbox')
if 'next' in request.GET:
success_url = request.GET['next']
return HttpResponseRedirect(success_url)
else:
form = form_class()
if recipient is not None:
recipients = [u for u in User.objects.filter(**{'%s__in' % get_username_field(): [r.strip() for r in recipient.split('+')]})]
form.fields['recipient'].initial = recipients
return render_to_response(template_name, {
'form': form,
}, context_instance=RequestContext(request))
def compose(request,
recipient=None,
form_class=ComposeForm,
template_name='django_messages/compose.html',
success_url=None,
recipient_filter=None):
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)
messages.info(request, _(u"Message successfully sent."))
if success_url is None:
success_url = reverse('messages_inbox')
if 'next' in request.GET:
success_url = request.GET['next']
return HttpResponseRedirect(success_url)
else:
form = form_class()
if recipient is not None:
recipients = [
u for u in User.objects.filter(
**{
'%s__in' % get_username_field():
[r.strip() for r in recipient.split('+')]
})
]
form.fields['recipient'].initial = recipients
return render_to_response(template_name, {
'form': form,
},
context_instance=RequestContext(request))
def compose(request, recipient=None, form_class=ComposeForm,
template_name='django_messages/compose.html', success_url=None, recipient_filter=None):
"""
Displays and handles the ``form_class`` form to compose new messages.
Required Arguments: None
Optional Arguments:
``recipient``: username of a `django.contrib.auth` User, who should
receive the message, optionally multiple usernames
could be separated by a '+'
``form_class``: the form-class to use
``template_name``: the template to use
``success_url``: where to redirect after successfull submission
"""
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)
messages.info(request, _(u"Message successfully sent."))
if success_url is None:
success_url = reverse('messages_inbox')
if 'next' in request.GET:
success_url = request.GET['next']
return HttpResponseRedirect(success_url)
else:
form = form_class()
if recipient is not None:
recipients = [u for u in User.objects.filter(**{'%s__in' % get_username_field(): [r.strip() for r in recipient.split('+')]})]
form.fields['recipient'].initial = recipients
return render(request, template_name, {
'form': form,
})
def pai_messages(request,
recipients=None,
template_name='django_messages/pai_messages.html'):
name = request.GET.get("name", None)
about = request.GET.get('about', None)
if recipients is not None:
recipients = [
u.public_key for u in User.objects.filter(
**{
'%s__in' % get_username_field():
[r.strip() for r in recipients.split('++')]
})
]
thread = {"recipients": recipients, "about": about, "name": name}
application = {
"namespace": settings.CATENA_PAIPASS_NAMESPACE,
"client_id": settings.PAIPASS_SSO_CLIENT_ID,
}
context = {
"thread": thread,
"application": application,
'PAIPASS_URL': '/'.join(settings.PAIPASS_DOMAIN.split('/')[:-1])
}
return render(request, template_name, context)
def render(self, name, value, attrs=None, **kwargs):
if value is None:
value = ''
elif isinstance(value, (list, tuple)):
value = (', '.join(
[getattr(user, get_username_field()) for user in value]))
return super(CommaSeparatedUserInput, self).render(name, value, attrs)
def prepare_value(self, value):
if value is None:
value = ''
elif isinstance(value, (list, tuple)):
value = (', '.join(
[getattr(user, get_username_field()) for user in value]))
return value
def compose(request, recipient=None, form_class=ComposeForm, model_class=Message,
template_name='django_messages/compose.html', success_url=None, recipient_filter=None):
"""
Displays and handles the ``form_class`` form to compose new messages.
Required Arguments: None
Optional Arguments:
``recipient``: username of a `django.contrib.auth` User, who should
receive the message, optionally multiple usernames
could be separated by a '+'
``form_class``: the form-class to use
``template_name``: the template to use
``success_url``: where to redirect after successfull submission
"""
if request.method == "POST":
sender = request.user
form = form_class(request.POST, recipient_filter=recipient_filter)
model = model_class()
if form.is_valid():
if "encrypt" in request.POST:
#key = request.POST.get('encrypt_key')
username = request.user
print(Keys.objects.all())
recipients=request.POST['recipient']
key = Keys.objects.get(username=recipients)
private_key = RSA.importKey(key.private_key)
public_key = private_key.publickey()
#message = encrypt_message(form.get_message().encode('utf-8'), key)
message = encrypt_message(form.get_message().encode('utf-8'), public_key)
print(message[0])
print(type(message[0]))
print(private_key.decrypt(message[0]))
message = base64.b64encode(message[0])
# print(message)
#enc = base64.b64encode(message) + b"\n\nKey is: " + key.encode('utf-8')
form.set_message(message)
form.set_tuple_byte(message)
form.save(request.user,message)
messages.info(request, _(u"Message successfully sent."))
if success_url is None:
success_url = reverse('messages_inbox')
if 'next' in request.GET:
success_url = request.GET['next']
return HttpResponseRedirect(success_url)
else:
form = form_class()
if recipient is not None:
recipients = [u for u in User.objects.filter(**{'%s__in' % get_username_field(): [r.strip() for r in recipient.split('+')]})]
form.fields['recipient'].initial = recipients
return render_to_response(template_name, {
'form': form,
}, context_instance=RequestContext(request))
def compose_w_data(request, recipient=None, body=None, subject=None, form_class=ComposeForm,template_name='django_messages/compose.html', success_url=None, recipient_filter=None):
"""
Displays and handles the ``form_class`` form to compose new messages.
Required Arguments: None
Optional Arguments:
``recipient``: username of a `django.contrib.auth` User, who should
receive the message, optionally multiple usernames
could be separated by a '+'
``form_class``: the form-class to use
``template_name``: the template to use
``success_url``: where to redirect after successfull submission
"""
tokenized_recipients = None
if request.method == "POST":
form = form_class(request.POST, recipient_filter=recipient_filter)
if form.is_valid():
form.save(sender=request.user)
messages.info(request, _(u"Message successfully sent."))
if success_url is None:
success_url = reverse('messages_inbox')
if 'next' in request.GET:
success_url = request.GET['next']
return HttpResponseRedirect(success_url)
else:
sender = request.user
if sender:
sender_username = sender.username
form = form_class()
recipient = request.GET.get('recipient',None)
if recipient is not None:
if ' ' in recipient:
splitted = recipient.split(' ')
else:
splitted = recipient.split('+')
body = request.GET.get('body', None)
subject = request.GET.get('subject', None)
if recipient is not None:
userlist = []
for r in splitted:
if r.strip() != sender_username:
u = User.objects.filter(**{'%s' % get_username_field(): r.strip()})
user = u.first()
if user:
userlist.append(user)
recipients = userlist
tokenized_recipients = tokenize_recipients(recipients)
# recipients = [u for u in User.objects.filter(**{'%s__in' % get_username_field(): [r.strip() for r in recipient.split('+')]})]
form.fields['recipient'].initial = recipients
if body is not None:
form.fields['body'].initial = body
if subject is not None:
form.fields['subject'].initial = subject
return render_to_response(template_name, {'form': form, 'tokenized_recipients': tokenized_recipients}, context_instance=RequestContext(request))
def compose_with_userto(request,
user_to,
recipient=None,
form_class=ComposeForm,
template_name='django_messages/compose.html',
success_url=None,
recipient_filter=None):
df = pd.DataFrame(
[u.email, u.username, u.slogan] for u in CustomUser.objects.raw(
'SELECT id, slogan, email FROM users_customuser where id=' +
user_to))
email_recipient = str(df.iloc[0, 0])
username = str(df.iloc[0, 1])
slogan = "Re: " + str(df.iloc[0, 2])
recipient = username
if request.method == "POST":
sender = request.user
form = form_class(request.POST, recipient_filter=recipient_filter)
if form.is_valid():
subject = form.cleaned_data['subject']
body = form.cleaned_data['body']
# send the mail
try:
send_mail(subject, body, '*****@*****.**',
[email_recipient])
except BadHeaderError:
return HttpResponse('Invalid header found.')
# store it in database
form.save(sender=request.user)
messages.info(request, _(u"Message successfully sent."))
if success_url is None:
success_url = reverse('messages_inbox')
if 'next' in request.GET:
success_url = request.GET['next']
return HttpResponseRedirect(success_url)
else:
form = form_class(initial={"subject": slogan})
if recipient is not None:
recipients = [
u for u in User.objects.filter(
**{
'%s__in' % get_username_field():
[r.strip() for r in recipient.split('+')]
})
]
form.fields['recipient'].initial = recipients
return render(request, template_name, {
'form': form,
})
def whisper(request,
subject,
recipient=None,
form_class=ComposeForm,
template_name='django_messages/compose.html',
success_url=None,
recipient_filter=None):
"""
Displays and handles the ``form_class`` form to compose new messages.
Required Arguments: None
Optional Arguments:
``recipient``: username of a `django.contrib.auth` User, who should
receive the message, optionally multiple usernames
could be separated by a '+'
``form_class``: the form-class to use
``template_name``: the template to use
``success_url``: where to redirect after successfull submission
``recipient_filter``: a function which receives a user object and
returns a boolean wether it is an allowed
recipient or not
Passing GET parameter ``subject`` to the view allows pre-filling the
subject field of the form.
"""
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)
messages.info(request, _(u"Message successfully sent."))
if success_url is None:
success_url = reverse('messages_inbox')
if 'next' in request.GET:
success_url = request.GET['next']
return HttpResponseRedirect(success_url)
else:
form = form_class(
initial={
"subject": request.GET.get("subject", "Storage#" + subject)
})
if recipient is not None:
recipients = [
u for u in User.objects.filter(
**{
'%s__in' % get_username_field():
[r.strip() for r in recipient.split('+')]
})
]
form.fields['recipient'].widget = HiddenInput()
form.fields['recipient'].initial = recipients
return render(request, template_name, {
'form': form,
})
def render(self, name, value, attrs=None):
if value is None:
value = ''
elif isinstance(value, (list, tuple)):
value = (', '.join([getattr(user, get_username_field()) for user in value]))
output = super(RecipientDisplayWidget, self).render(name, value, attrs)
display = value
if display is None:
display = 'None'
elif isinstance(display, (list, tuple)):
display = (', '.join([self._format_display(user) for user in display]))
else:
display = self._format_display(display)
return mark_safe(u'<span>%s%s</span>' % (display, output))
def compose(request, recipient=None, form_class=ComposeForm,
template_name='django_messages/compose.html', success_url=None, recipient_filter=None):
"""
Displays and handles the ``form_class`` form to compose new messages.
Required Arguments: None
Optional Arguments:
``recipient``: username of a `django.contrib.auth` User, who should
receive the message, optionally multiple usernames
could be separated by a '+'
``form_class``: the form-class to use
``template_name``: the template to use
``success_url``: where to redirect after successfull submission
"""
profile_list = []
profiles_one = ProfileProfileConnection.objects.filter(sec_profile__username=request.user.username,
rejected_connection=False,
connected=True)
for profile in profiles_one:
profile_user = ProfileProfileConnection.objects.get(pk=str(profile)).first_profile.username
variable = User.objects.get(username=profile_user)
profile_list.append(variable)
profiles_two = ProfileProfileConnection.objects.filter(first_profile__username=request.user.username,
rejected_connection=False,
connected=True)
for profile in profiles_two:
profile_user = ProfileProfileConnection.objects.get(pk=str(profile)).sec_profile.username
variable = User.objects.get(username=profile_user)
profile_list.append(variable)
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)
messages.info(request, _(u"Message successfully sent."))
if success_url is None:
success_url = reverse('messages_inbox')
if 'next' in request.GET:
success_url = request.GET['next']
return HttpResponseRedirect(success_url)
else:
form = form_class()
if recipient is not None:
recipients = [u for u in User.objects.filter(
**{'%s__in' % get_username_field(): [r.strip() for r in recipient.split('+')]})]
form.fields['recipient'].initial = recipients
return render(request, template_name, {
'form': form,
'profile_list': profile_list,
})
def compose(request, recipient=None, form_class=ComposeForm,
template_name='django_messages/compose.html', success_url=None, recipient_filter=None):
"""
Displays and handles the ``form_class`` form to compose new messages.
Required Arguments: None
Optional Arguments:
``recipient``: username of a `django.contrib.auth` User, who should
receive the message, optionally multiple usernames
could be separated by a '+'
``form_class``: the form-class to use
``template_name``: the template to use
``success_url``: where to redirect after successfull submission
"""
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)
messages.info(request, _(u"Message successfully sent."))
email_to = User.objects.get(userName=request.POST.get("recipient", ""))
email_word = email_to.email
email_to.has_messages = True
email_to.save()
subject = "New Message: " + request.POST.get("subject", "")
msg = render_to_string('django_messages/new_message_email.html', {'recipient': request.POST.get("recipient", ""), 'sender': sender.userName, 'message': request.POST.get("body", "")})
if (email_to.emailEvery == 0):
email_to.has_messages = False
email_to.save()
send_mail(subject, 'You have a new message.', '*****@*****.**', [email_word], fail_silently=False, html_message=msg)
if success_url is None:
success_url = reverse('messages_inbox')
if 'next' in request.GET:
success_url = request.GET['next']
if (email_to.has_messages == True):
cough = "yes"
else:
cough = "no"
#return render(request, 'django_messages/nameright.html', {'name': cough})
return HttpResponseRedirect(success_url)
else:
form = form_class()
if recipient is not None:
recipients = [u for u in User.objects.filter(**{'%s__in' % get_username_field(): [r.strip() for r in recipient.split('+')]})]
form.fields['recipient'].initial = recipients
return render_to_response(template_name, {
'form': form,
}, context_instance=RequestContext(request))
def clean(self, value):
super(CommaSeparatedUserField, self).clean(value)
if not value:
return ''
if isinstance(value, (list, tuple)):
return value.title()
names = set(value.split(','))
names_set = set([name.strip() for name in names if name.strip()])
users = list(
User.objects.filter(
**{'%s__in' % get_username_field(): names_set}))
unknown_names = names_set ^ set(
[getattr(user, get_username_field()) for user in users])
recipient_filter = self._recipient_filter
invalid_users = []
if recipient_filter is not None:
for r in users:
if recipient_filter(r) is False:
users.remove(r)
invalid_users.append(getattr(r, get_username_field()))
return users
def contact(
request, slug, recipient=None, success_url=None, recipient_filter=None
):
row = get_object_or_404(Ad, slug=slug)
if request.method == "POST":
# sender = request.user
form = ComposeForm(request.POST, recipient_filter=recipient_filter)
if form.is_valid():
form.save(sender=request.user)
messages.info(request, "Message and email successfully sent.")
if success_url is None:
success_url = reverse("ads:ad_detail", kwargs={"slug": slug})
if "next" in request.GET:
success_url = request.GET["next"]
return HttpResponseRedirect(success_url)
else:
form = ComposeForm(
initial={"recipient": row.user.username, "subject": row.title}
)
if recipient is not None:
recipients = [
u
for u in User.objects.filter(
**{
"%s__in"
% get_username_field(): [
r.strip() for r in recipient.split("+")
]
}
)
]
form.fields["recipient"].initial = recipients
context = {
"form": form,
}
return render(request, "ads/contact.html", context)
def post_public_list(request,
pk,
recipient=None,
form_class=ComposeForm,
template_name='django_messages/composep.html',
success_url=None,
recipient_filter=None):
post = get_object_or_404(Product, pk=pk)
#zipcode = User.objects.filter(name = 121212)
zipcode = User.objects.all()
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)
messages.info(request, (u"Message successfully sent."))
if success_url is None:
success_url = reverse('home')
if 'next' in request.GET:
success_url = request.GET['next']
return HttpResponseRedirect('/messages/inbox/')
# return render(request, 'products/post_list.html', {'posts': posts })
else:
form = form_class()
if recipient is not None:
recipients = [
u for u in User.objects.filter(
**{
'%s__in' % get_username_field():
[r.strip() for r in recipient.split('+')]
})
]
form.fields['recipient'].initial = recipients
return render_to_response('products/productmsg.html', {
'form': form,
'post': post,
'zipcode': zipcode,
},
context_instance=RequestContext(request))
def contact(request,
slug,
recipient=None,
success_url=None,
recipient_filter=None):
row = get_object_or_404(Ad, slug=slug)
if request.method == "POST":
form = ComposeForm(request.POST, recipient_filter=recipient_filter)
if form.is_valid():
subject = form.cleaned_data['subject']
message = form.cleaned_data['body']
sender = request.user.email
recipient = row.user.email
form.save(sender=request.user)
send_mail(subject, message, sender, [recipient])
messages.info(request, "Message successfully sent.")
if success_url is None:
success_url = reverse('ads:ad', kwargs={'slug': slug})
if 'next' in request.GET:
success_url = request.GET['next']
return HttpResponseRedirect(success_url)
else:
form = ComposeForm(initial={
'recipient': row.user.username,
'subject': row.title
})
if recipient is not None:
recipients = [
u for u in User.objects.filter(
**{
'%s__in' % get_username_field():
[r.strip() for r in recipient.split('+')]
})
]
form.fields['recipient'].initial = recipients
return render(request, 'ads/contact.html', {'form': form})
def public_service(request, pk, recipient=None, form_class=ComposeForm,
template_name='django_messages/composes.html', success_url=None, recipient_filter=None):
post1 = get_object_or_404(Service, pk=pk)
#zipcode = User.objects.filter(name = 121212)
zipcode = User.objects.all()
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)
messages.info(request, _(u"Message successfully sent."))
if success_url is None:
success_url = reverse('home')
if 'next' in request.GET:
success_url = request.GET['next']
return HttpResponseRedirect(success_url)
# return render(request, 'products/post_list.html', {'posts': posts })
else:
form = form_class()
if recipient is not None:
recipients = [u for u in User.objects.filter(**{'%s__in' % get_username_field(): [r.strip() for r in recipient.split('+')]})]
form.fields['recipient'].initial = recipients
return render_to_response('django_messages/composes.html', {'form': form, 'post1': post1, 'zipcode': zipcode, }, context_instance=RequestContext(request))
def render(self, name, value, attrs=None):
if value is None:
value = ''
elif isinstance(value, (list, tuple)):
value = (', '.join([getattr(user, get_username_field()) for user in value]))
return super(CommaSeparatedUserInput, self).render(name, value, attrs)
def compose(request,
recipient=None,
form_class=ComposeForm,
template_name='django_messages/compose.html',
success_url=None,
recipient_filter=None):
"""
Displays and handles the ``form_class`` form to compose new messages.
Required Arguments: None
Optional Arguments:
``recipient``: username of a `django.contrib.auth` User, who should
receive the message, optionally multiple usernames
could be separated by a '+'
``form_class``: the form-class to use
``template_name``: the template to use
``success_url``: where to redirect after successfull submission
"""
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)
messages.info(request, _(u"Message successfully sent."))
email_to = User.objects.get(
userName=request.POST.get("recipient", ""))
email_word = email_to.email
email_to.has_messages = True
email_to.save()
subject = "New Message: " + request.POST.get("subject", "")
msg = render_to_string(
'django_messages/new_message_email.html', {
'recipient': request.POST.get("recipient", ""),
'sender': sender.userName,
'message': request.POST.get("body", "")
})
if (email_to.emailEvery == 0):
email_to.has_messages = False
email_to.save()
send_mail(subject,
'You have a new message.',
'*****@*****.**', [email_word],
fail_silently=False,
html_message=msg)
if success_url is None:
success_url = reverse('messages_inbox')
if 'next' in request.GET:
success_url = request.GET['next']
if (email_to.has_messages == True):
cough = "yes"
else:
cough = "no"
#return render(request, 'django_messages/nameright.html', {'name': cough})
return HttpResponseRedirect(success_url)
else:
form = form_class()
if recipient is not None:
recipients = [
u for u in User.objects.filter(
**{
'%s__in' % get_username_field():
[r.strip() for r in recipient.split('+')]
})
]
form.fields['recipient'].initial = recipients
return render_to_response(template_name, {
'form': form,
},
context_instance=RequestContext(request))
def prepare_value(self, value):
if value is None:
value = ''
elif isinstance(value, (list, tuple)):
value = (', '.join([getattr(user, get_username_field()) for user in value]))
return value
def compose(request, recipient=None, form_class=ComposeForm,
template_name='django_messages/compose.html', success_url=None, recipient_filter=None):
"""
Displays and handles the ``form_class`` form to compose new messages.
Required Arguments: None
Optional Arguments:
``recipient``: username of a `django.contrib.auth` User, who should
receive the message, optionally multiple usernames
could be separated by a '+'
``form_class``: the form-class to use
``template_name``: the template to use
``success_url``: where to redirect after successfull submission
"""
user_role = User_Roles.objects.get(user_userid=request.user).role_roleid;
organisation = User_Organisations.objects.get(user_userid=request.user).organisation_organisationid;
current_user_role = user_role.role_name;
current_user = "******" + request.user.first_name + ". You are a " + current_user_role + " in " + organisation.organisation_name + " organisation."
users= User.objects.filter(pk__in=User_Organisations.objects.filter(organisation_organisationid=organisation).values_list('user_userid', flat=True)).exclude(pk__in=UserProfile.objects.filter(admin_approved=False).values_list('user', flat=True)).filter(is_active=True)
users_as_json = serializers.serialize('json', users)
users_as_json =json.loads(users_as_json)
if request.method == "POST":
sender = request.user
form = form_class(request.POST, recipient_filter=recipient_filter)
post=request.POST
"""
print(post)
parent_msg=None
recipients = request.POST.getlist('to')
subject = post['subject']
body = post['body']
message_list = []
print(recipients)
print(subject)
print(body)
for r in recipients:
print("looping user: "******"messages_replied", {'message': msg,})
notification.send([r], "messages_reply_received", {'message': msg,})
else:
notification.send([sender], "messages_sent", {'message': msg,})
notification.send([r], "messages_received", {'message': msg,})
return message_list
"""
if form.is_valid():
form.save(sender=request.user)
messages.info(request, _(u"Message successfully sent."))
if success_url is None:
success_url = reverse('messages_inbox')
if 'next' in request.GET:
success_url = request.GET['next']
return HttpResponseRedirect(success_url)
else:
form = form_class()
if recipient is not None:
recipients = [u for u in User.objects.filter(**{'%s__in' % get_username_field(): [r.strip() for r in recipient.split('+')]})]
form.fields['recipient'].initial = recipients
return render_to_response(template_name, {
'form': form, 'current_user':current_user, 'users':users,'users_as_json':users_as_json,
}, context_instance=RequestContext(request))
