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