def test_get_protocol(self): """ Test if the correct protocol is returned """ self.failUnlessEqual(get_protocol(), 'http') userena_settings.USERENA_USE_HTTPS = True self.failUnlessEqual(get_protocol(), 'https') userena_settings.USERENA_USE_HTTPS = False
def test_get_protocol(self): """ Test if the correct protocol is returned """ self.failUnlessEqual(get_protocol(), 'http') userena_settings.USERENA_USE_HTTPS = True self.failUnlessEqual(get_protocol(), 'https') userena_settings.USERENA_USE_HTTPS = False
def send_activation_email(self): """ Sends a activation email to the user. This email is send when the user wants to activate their newly created user. """ context= {'user': self.user, 'without_usernames': userena_settings.USERENA_WITHOUT_USERNAMES, 'protocol': get_protocol(), 'activation_days': userena_settings.USERENA_ACTIVATION_DAYS, 'activation_key': self.activation_key, 'site': Site.objects.get_current()} subject = render_to_string('userena/emails/activation_email_subject.txt', context) subject = ''.join(subject.splitlines()) message = render_to_string('userena/emails/activation_email_message.txt', context) try: send_mail(subject, message, settings.DEFAULT_FROM_EMAIL, [self.user.email,]) except: pass
def send_confirmation_email(self): """ Sends an email to confirm the new email address. This method sends out two emails. One to the new email address that contains the ``email_confirmation_key`` which is used to verify this this email address with :func:`UserenaUser.objects.confirm_email`. The other email is to the old email address to let the user know that a request is made to change this email address. """ context = { "user": self.user, "without_usernames": userena_settings.USERENA_WITHOUT_USERNAMES, "new_email": self.email_unconfirmed, "protocol": get_protocol(), "confirmation_key": self.email_confirmation_key, "site": shortcuts.get_current_site(request=None), } mailer = UserenaConfirmationMail(context=context) mailer.generate_mail("confirmation", "_old") if self.user.email: mailer.send_mail(self.user.email) mailer.generate_mail("confirmation", "_new") mailer.send_mail(self.email_unconfirmed)
def send_confirmation_email(self): # TODO !!!!!!!!! context = {'user': self.user, 'without_usernames': userena_settings.USERENA_WITHOUT_USERNAMES, 'new_email': self.email_unconfirmed, 'protocol': get_protocol(), 'confirmation_key': self.email_confirmation_key, 'site': Site.objects.get_current()} # Email to the old address, if present subject_old = render_to_string('userena/emails/confirmation_email_subject_old.txt', context) subject_old = ''.join(subject_old.splitlines()) message_old = render_to_string('userena/emails/confirmation_email_message_old.txt', context) if self.user.email: send_mail(subject_old, message_old, settings.DEFAULT_FROM_EMAIL, [self.user.email]) # Email to the new address subject_new = render_to_string('userena/emails/confirmation_email_subject_new.txt', context) subject_new = ''.join(subject_new.splitlines()) message_new = render_to_string('userena/emails/confirmation_email_message_new.txt', context) send_mail(subject_new, message_new, settings.DEFAULT_FROM_EMAIL, [self.email_unconfirmed, ])
def send_message_notification(sender, instance, **kwargs): """ Send email when user receives a new message. This email contains the full text and a link to read it online. We trigger this when a MessageRecipient is saved and not when a Message is saved because umessages first saves a message and then adds its recipients, so when a Message is saved, it doesn't yet have a list of recipients. """ if not instance.user.email: # Email can be missing for users registered with Twitter # or LinkedIn return params = { 'sender': instance.message.sender.username, 'body': instance.message.body, } message_url_path = reverse('userena_umessages_detail', kwargs={'username': params['sender']}) params['message_url'] = "%s://%s%s" % ( get_protocol(), Site.objects.get_current(), message_url_path) subject = _(u'Message from %(sender)s') % params message = render_to_string('umessages/message_notification.txt', params) recipient = instance.user.email send_mail(subject, message, settings.DEFAULT_FROM_EMAIL, [recipient])
def send_activation_email(self): """ Sends a activation email to the user. This email is send when the user wants to activate their newly created user. """ context = { 'user': self.user, 'without_usernames': userena_settings.USERENA_WITHOUT_USERNAMES, 'protocol': get_protocol(), 'activation_days': userena_settings.USERENA_ACTIVATION_DAYS, 'activation_key': self.activation_key, 'site': Site.objects.get_current() } subject = render_to_string( 'userena/emails/activation_email_subject.txt', context) subject = ''.join(subject.splitlines()) message = render_to_string( 'userena/emails/activation_email_message.txt', context) send_mail(subject, message, settings.DEFAULT_FROM_EMAIL, [ self.user.email, ])
def send_invite_email(self, promoter): """ Sends a invitation email to the user. This email is sent when a user invites another user to to join. """ context = {'user': self.user, 'promoter': promoter, 'without_usernames': userena_settings.USERENA_WITHOUT_USERNAMES, 'protocol': get_protocol(), 'activation_days': userena_settings.USERENA_ACTIVATION_DAYS, 'activation_key': self.activation_key, 'site': Site.objects.get_current()} subject = render_to_string('userena/emails/invitation_email_subject.txt', context) subject = ''.join(subject.splitlines()) message = render_to_string('userena/emails/invitation_email_message.txt', context) send_mail(subject, message, settings.DEFAULT_FROM_EMAIL, [self.user.email,])
def send_confirmation_email(self): """ Sends an email to confirm the new email address. This method sends out two emails. One to the new email address that contains the ``email_confirmation_key`` which is used to verify this this email address with :func:`UserenaUser.objects.confirm_email`. The other email is to the old email address to let the user know that a request is made to change this email address. """ context = { "user": self.user, "new_email": self.email_unconfirmed, "protocol": get_protocol(), "confirmation_key": self.email_confirmation_key, "site": Site.objects.get_current(), } # Email to the old address subject_old = render_to_string("userena/emails/confirmation_email_subject_old.txt", context) subject_old = "".join(subject_old.splitlines()) message_old = render_to_string("userena/emails/confirmation_email_message_old.txt", context) send_mail(subject_old, message_old, settings.DEFAULT_FROM_EMAIL, [self.user.email]) # Email to the new address subject_new = render_to_string("userena/emails/confirmation_email_subject_new.txt", context) subject_new = "".join(subject_new.splitlines()) message_new = render_to_string("userena/emails/confirmation_email_message_new.txt", context) send_mail(subject_new, message_new, settings.DEFAULT_FROM_EMAIL, [self.email_unconfirmed])
def send_confirmation_email(self): # TODO !!!!!!!!! context = { 'user': self.user, 'without_usernames': userena_settings.USERENA_WITHOUT_USERNAMES, 'new_email': self.email_unconfirmed, 'protocol': get_protocol(), 'confirmation_key': self.email_confirmation_key, 'site': Site.objects.get_current() } # Email to the old address, if present subject_old = render_to_string( 'userena/emails/confirmation_email_subject_old.txt', context) subject_old = ''.join(subject_old.splitlines()) message_old = render_to_string( 'userena/emails/confirmation_email_message_old.txt', context) if self.user.email: send_mail(subject_old, message_old, settings.DEFAULT_FROM_EMAIL, [self.user.email]) # Email to the new address subject_new = render_to_string( 'userena/emails/confirmation_email_subject_new.txt', context) subject_new = ''.join(subject_new.splitlines()) message_new = render_to_string( 'userena/emails/confirmation_email_message_new.txt', context) send_mail(subject_new, message_new, settings.DEFAULT_FROM_EMAIL, [ self.email_unconfirmed, ])
def send_confirmation_email(self): """ Sends an email to confirm the new email address. This method sends out two emails. One to the new email address that contains the ``email_confirmation_key`` which is used to verify this this email address with :func:`UserenaUser.objects.confirm_email`. The other email is to the old email address to let the user know that a request is made to change this email address. """ context = {'user': self.user, 'without_usernames': userena_settings.USERENA_WITHOUT_USERNAMES, 'new_email': self.email_unconfirmed, 'protocol': get_protocol(), 'confirmation_key': self.email_confirmation_key, 'site': Site.objects.get_current()} mailer = UserenaConfirmationMail(context=context) mailer.generate_mail("confirmation", "_old") if self.user.email: mailer.send_mail(self.user.email) mailer.generate_mail("confirmation", "_new") mailer.send_mail(self.email_unconfirmed)
def send_activation_email(self, first_name = '', last_name = ''): """ Sends a activation email to the user. This email is send when the user wants to activate their newly created user. """ context = {'user': self.user, 'first_name': first_name, 'last_name': last_name, 'without_usernames': userena_settings.USERENA_WITHOUT_USERNAMES, 'protocol': get_protocol(), 'activation_days': userena_settings.USERENA_ACTIVATION_DAYS, 'activation_key': self.activation_key, 'site': Site.objects.get_current()} subject = render_to_string('userena/emails/activation_email_subject.txt', context) subject = ''.join(subject.splitlines()) text_content = render_to_string('userena/emails/activation_email_message.txt', context) html_content = render_to_string('userena/emails/activation_email_message.html', context) email = EmailMultiAlternatives(subject, text_content, settings.DEFAULT_FROM_EMAIL, [self.user.email, ]) email.attach_alternative(html_content, "text/html") email.send()
def versende_activation(self): """ Autogeneriere pw und versende activation mail incl. pw """ # activation Mail mit pw versenden from userena.mail import UserenaConfirmationMail import userena.settings as userena_settings from django.contrib.sites.models import Site from userena.utils import get_protocol signup = self.userena_signup password = self.erzeuge_pw() context = { 'user': signup.user, 'without_usernames': userena_settings.USERENA_WITHOUT_USERNAMES, 'protocol': get_protocol(), 'activation_days': userena_settings.USERENA_ACTIVATION_DAYS, 'activation_key': signup.activation_key, 'site': Site.objects.get_current(), 'passwort': password } mailer = UserenaConfirmationMail(context=context) mailer.generate_mail("activation") mailer.send_mail(signup.user.email) self.set_password(password) self.save()
def send_approval_email(self): """ Sends an approval email to the user. This email is sent when USERENA_MODERATE_REGISTRATION, after an admin has approved the registration. """ context = { 'user': self.user, 'protocol': get_protocol(), 'site': Site.objects.get_current() } subject = render_to_string('userena/emails/approval_email_subject.txt', context) subject = ''.join(subject.splitlines()) message = render_to_string('userena/emails/approval_email_message.txt', context) if userena_settings.USERENA_HTML_EMAIL: message_html = render_to_string( 'userena/emails/approval_email_message.html', context) else: message_html = None send_mail(subject, message, message_html, settings.DEFAULT_FROM_EMAIL, [ self.user.email, ])
def send_approval_email(self): """ Sends an approval email to the user. This email is sent when USERENA_MODERATE_REGISTRATION, after an admin has approved the registration. """ context= {'user': self.user, 'protocol': get_protocol(), 'site': Site.objects.get_current()} subject = render_to_string('userena/emails/approval_email_subject.txt', context) subject = ''.join(subject.splitlines()) message = render_to_string('userena/emails/approval_email_message.txt', context) if userena_settings.USERENA_HTML_EMAIL: message_html = render_to_string('userena/emails/approval_email_message.html', context) else: message_html = None send_mail(subject, message, message_html, settings.DEFAULT_FROM_EMAIL, [self.user.email,])
def send_message_notification(sender, instance, **kwargs): """ Send email when user receives a new message. This email contains the full text and a link to read it online. We trigger this when a MessageRecipient is saved and not when a Message is saved because umessages first saves a message and then adds its recipients, so when a Message is saved, it doesn't yet have a list of recipients. """ if not instance.user.email: # Email can be missing for users registered with Twitter # or LinkedIn return params = {"sender": instance.message.sender.username, "body": instance.message.body} message_url_path = reverse("userena_umessages_detail", kwargs={"username": params["sender"]}) params["message_url"] = "%s://%s%s" % (get_protocol(), Site.objects.get_current(), message_url_path) subject = _(u"New message from %(sender)s on Imagination For People") % params message = render_to_string("umessages/message_notification.txt", params) recipient = instance.user.email # XXX Resets the Content-Transfer-Encoding in email header # Avoids bad encoding of UTF-8 body # See https://code.djangoproject.com/ticket/3472 from email import Charset Charset.add_charset("utf-8", Charset.SHORTEST, "utf-8", "utf-8") send_mail(subject, message, settings.DEFAULT_FROM_EMAIL, [recipient])
def send_activation_email(self): """ Sends a activation email to the user. This email is sent_activation_email when the user wants to activate their newly created user. """ context = {'user': self.user, 'without_usernames': userena_settings.USERENA_WITHOUT_USERNAMES, 'protocol': get_protocol(), 'activation_days': userena_settings.USERENA_ACTIVATION_DAYS, 'activation_key': self.activation_key, 'site': Site.objects.get_current()} mailer = UserenaConfirmationMail(context=context) mailer.generate_mail("activation") mailer.send_mail(self.user.email) #Send email to admins with the same message emaillist = [] if settings.USERENA_ADMIN_MODERATION: for k, v in settings.ADMINS: emaillist.append(v) send_mail(settings.SITE_NAME + " - Activation done", message, message_html, settings.DEFAULT_FROM_EMAIL, emaillist)
def send_confirmation_email(self): """ Sends an email to confirm the new email address. This method sends out two emails. One to the new email address that contains the ``email_confirmation_key`` which is used to verify this this email address with :func:`UserenaUser.objects.confirm_email`. The other email is to the old email address to let the user know that a request is made to change this email address. """ context = { 'user': self.user, 'without_usernames': userena_settings.USERENA_WITHOUT_USERNAMES, 'new_email': self.email_unconfirmed, 'protocol': get_protocol(), 'confirmation_key': self.email_confirmation_key, 'site': Site.objects.get_current() } mailer = UserenaConfirmationMail(context=context) mailer.generate_mail("confirmation", "_old") if self.user.email: mailer.send_mail(self.user.email) mailer.generate_mail("confirmation", "_new") mailer.send_mail(self.email_unconfirmed)
def send_activation_email(self): """ Sends a activation email to the user. This email is send when the user wants to activate their newly created user. """ context= {'user': self.user, 'without_usernames': userena_settings.USERENA_WITHOUT_USERNAMES, 'protocol': get_protocol(), 'activation_days': userena_settings.USERENA_ACTIVATION_DAYS, 'activation_key': self.activation_key, 'site': Site.objects.get_current()} subject = render_to_string('userena/emails/activation_email_subject.txt', context) subject = ''.join(subject.splitlines()) message = render_to_string('userena/emails/activation_email_message.txt', context) # EMRE Modified this to use smtplib. This method doesn't work. send_mail(subject, message, settings.DEFAULT_FROM_EMAIL, [self.user.email,]) """msg = ("From: %s\r\nTo: %s\r\nSubject:%s\r\n\r\n%s\r\n"
def send_activation_email( self, template="userena/emails/activation_email_message.txt", headers=None, attach_list=[] ): """ Sends a activation email to the user. This email is send when the user wants to activate their newly created user. """ context = { "user": self.user, "without_usernames": userena_settings.USERENA_WITHOUT_USERNAMES, "protocol": get_protocol(), "activation_days": userena_settings.USERENA_ACTIVATION_DAYS, "activation_key": self.activation_key, "site": Site.objects.get_current(), } subject = render_to_string("userena/emails/activation_email_subject.txt", context) subject = "".join(subject.splitlines()) body = render_to_string(template, context) message = EmailMessage(subject, body, settings.DEFAULT_FROM_EMAIL, [self.user.email], headers=headers) if template.split(".")[-1] == "html": message.content_subtype = "html" for attachment in attach_list: message.attach(attachment) message.send()
def send_activation_email(self): """ Sends a activation email to the user. This email is send when the user wants to activate their newly created user. """ context = {'user': self.user, 'without_usernames': userena_settings.USERENA_WITHOUT_USERNAMES, 'protocol': get_protocol(), 'activation_days': userena_settings.USERENA_ACTIVATION_DAYS, 'activation_key': self.activation_key, 'site': Site.objects.get_current(), 'settings': settings} subject = render_to_string(userena_settings.USERENA_ACTIVATION_EMAIL_SUBJECT_TEMPLATE, context) subject = ''.join(subject.splitlines()) message = render_to_string(userena_settings.USERENA_ACTIVATION_EMAIL_MESSAGE_TEMPLATE, context) send_mail_module = importlib.import_module(userena_settings.USERENA_SEND_EMAIL_MODULE) send_mail_module.send_mail(subject, message, settings.DEFAULT_FROM_EMAIL, [self.user.email, ])
def send_activation_email_with_password(userena_signup_obj, password): """ Sends a activation email to the user, along with an automatically generated password that they need to log in. This function only exists because userena/models.py's UserenaSignup.send_activation_email() doesn't have a way to add custom context. """ context= {'user': userena_signup_obj.user, 'protocol': get_protocol(), 'activation_days': userena_settings.USERENA_ACTIVATION_DAYS, 'activation_key': userena_signup_obj.activation_key, 'site': Site.objects.get_current(), 'password': password} subject = render_to_string('userena/emails/activation_email_subject.txt', context) subject = ''.join(subject.splitlines()) message = render_to_string('userena/emails/activation_email_message.txt', context) send_mail(subject, message, settings.DEFAULT_FROM_EMAIL, [userena_signup_obj.user.email,])
def send_confirmation_email(self): """ Sends an email to confirm the new email address. This method sends out two emails. One to the new email address that contains the ``email_confirmation_key`` which is used to verify this this email address with :func:`UserenaUser.objects.confirm_email`. The other email is to the old email address to let the user know that a request is made to change this email address. """ context = {'user': self.user, 'without_usernames': userena_settings.USERENA_WITHOUT_USERNAMES, 'new_email': self.email_unconfirmed, 'protocol': get_protocol(), 'confirmation_key': self.email_confirmation_key, 'site': Site.objects.get_current()} # Email to the old address, if present subject_old = render_to_string('userena/emails/confirmation_email_subject_old.txt', context) subject_old = ''.join(subject_old.splitlines()) message_old_text = render_to_string('userena/emails/confirmation_email_message_old.txt', context) message_old_html = render_to_string('userena/emails/confirmation_email_message_old.html', context) if self.user.email: subject, from_email, to = subject_old, settings.DEFAULT_FROM_EMAIL, self.user.email text_content = message_old_text html_content = message_old_html msg = EmailMultiAlternatives(subject, text_content, from_email, [to]) msg.attach_alternative(html_content, "text/html") msg.send() # send_mail(subject_old, # message_old, # settings.DEFAULT_FROM_EMAIL, # [self.user.email]) # Email to the new address subject_new = render_to_string('userena/emails/confirmation_email_subject_new.txt', context) subject_new = ''.join(subject_new.splitlines()) message_new_text = render_to_string('userena/emails/confirmation_email_message_new.txt', context) message_new_html = render_to_string('userena/emails/confirmation_email_message_new.html', context) subject, from_email, to = subject_new, settings.DEFAULT_FROM_EMAIL, self.user.email text_content = message_new_text html_content = message_new_html msg = EmailMultiAlternatives(subject, text_content, from_email, [to]) msg.attach_alternative(html_content, "text/html") msg.send()
def send_pending_activation_email(self, organization=""): """ Sends a email to the user after signup. This email is sent_pending_activation_email when the user created a new user. """ context = {'user': self.user, 'without_usernames': userena_settings.USERENA_WITHOUT_USERNAMES, 'organization': organization, 'protocol': get_protocol(), 'activation_days': userena_settings.USERENA_ACTIVATION_DAYS, 'activation_key': self.activation_key, 'site': Site.objects.get_current()} subject = render_to_string('userena/emails/pending_activation_email_subject.txt', context) subject = ''.join(subject.splitlines()) message = render_to_string('userena/emails/pending_activation_email_message.txt', context) if userena_settings.USERENA_HTML_EMAIL: message_html = render_to_string('userena/emails/pending_activation_email_message.html', context) else: message_html = None #Send email to admins with the link activation of new user emaillist = [] if settings.USERENA_ADMIN_MODERATION: send_mail(subject, message, message_html, settings.DEFAULT_FROM_EMAIL, [self.user.email, ]) for k, v in settings.ADMINS: emaillist.append(v) else: emaillist.append(self.user.email) if userena_settings.USERENA_HTML_EMAIL: message = render_to_string('userena/emails/admin_activation_email_message.html', context) else: message = render_to_string('userena/emails/admin_activation_email_message.txt', context) send_mail(settings.SITE_NAME + "- Pending activation", message, settings.DEFAULT_FROM_EMAIL, emaillist)
def send_pending_activation_email(self, organization=""): """ Sends a email to the user after signup. This email is sent_pending_activation_email when the user created a new user. """ context = { 'user': self.user, 'without_usernames': userena_settings.USERENA_WITHOUT_USERNAMES, 'organization': organization, 'protocol': get_protocol(), 'activation_days': userena_settings.USERENA_ACTIVATION_DAYS, 'activation_key': self.activation_key, 'site': Site.objects.get_current() } subject = render_to_string( 'userena/emails/pending_activation_email_subject.txt', context) subject = ''.join(subject.splitlines()) message = render_to_string( 'userena/emails/pending_activation_email_message.txt', context) if userena_settings.USERENA_HTML_EMAIL: message_html = render_to_string( 'userena/emails/pending_activation_email_message.html', context) else: message_html = None #Send email to admins with the link activation of new user emaillist = [] if settings.USERENA_ADMIN_MODERATION: send_mail(subject, message, message_html, settings.DEFAULT_FROM_EMAIL, [ self.user.email, ]) for k, v in settings.ADMINS: emaillist.append(v) else: emaillist.append(self.user.email) message = render_to_string( 'userena/emails/admin_activation_email_message.txt', context) if userena_settings.USERENA_HTML_EMAIL: message_html = render_to_string( 'userena/emails/admin_activation_email_message.html', context) send_mail("EMIF Catalogue - Pending activation", message, message_html, settings.DEFAULT_FROM_EMAIL, emaillist)
def send_activation_email(self): """ Sends a activation email to the user. This email is sent_activation_email when the user wants to activate their newly created user. """ context = {'user': self.user, 'without_usernames': userena_settings.USERENA_WITHOUT_USERNAMES, 'protocol': get_protocol(), 'activation_days': userena_settings.USERENA_ACTIVATION_DAYS, 'activation_key': self.activation_key, 'site': Site.objects.get_current()} subject = render_to_string('userena/emails/activation_email_subject.txt', context) subject = ''.join(subject.splitlines()) if userena_settings.USERENA_HTML_EMAIL: message_html = render_to_string('userena/emails/activation_email_message.html', context) else: message_html = None if (not userena_settings.USERENA_HTML_EMAIL or not message_html or userena_settings.USERENA_USE_PLAIN_TEMPLATE): message = render_to_string('userena/emails/activation_email_message.txt', context) else: message = None send_mail(subject, message, message_html, settings.DEFAULT_FROM_EMAIL, [self.user.email, ]) #Send email to admins with the message that the new user is active if settings.USERENA_ADMIN_MODERATION: for k, v in settings.ADMINS: emaillist.append(v) else: emaillist.append(self.user.email) send_mail("EMIF Catalogue - Activation done", message, settings.DEFAULT_FROM_EMAIL, emaillist)
def send_activation_email(self): """ Sends a activation email to the user. This email is sent_activation_email when the user wants to activate their newly created user. """ context = { 'user': self.user, 'without_usernames': userena_settings.USERENA_WITHOUT_USERNAMES, 'protocol': get_protocol(), 'activation_days': userena_settings.USERENA_ACTIVATION_DAYS, 'activation_key': self.activation_key, 'site': Site.objects.get_current() } subject = render_to_string( 'userena/emails/activation_email_subject.txt', context) subject = ''.join(subject.splitlines()) if userena_settings.USERENA_HTML_EMAIL: message_html = render_to_string( 'userena/emails/activation_email_message.html', context) else: message_html = None if (not userena_settings.USERENA_HTML_EMAIL or not message_html or userena_settings.USERENA_USE_PLAIN_TEMPLATE): message = render_to_string( 'userena/emails/activation_email_message.txt', context) else: message = None send_mail(subject, message, message_html, settings.DEFAULT_FROM_EMAIL, [ self.user.email, ]) #Send email to admins with the message that the new user is active if settings.USERENA_ADMIN_MODERATION: for k, v in settings.ADMINS: emaillist.append(v) else: emaillist.append(self.user.email) send_mail("EMIF Catalogue - Activation done", message, settings.DEFAULT_FROM_EMAIL, emaillist)
def send_activation_email(self): """ Sends a activation email to the user. This email is send when the user wants to activate their newly created user. Override default userena mechanism, to send beautiful HTML email """ email_context = {'user': self.user, 'without_usernames': userena_settings.USERENA_WITHOUT_USERNAMES, 'protocol': get_protocol(), 'activation_days': userena_settings.USERENA_ACTIVATION_DAYS, 'activation_key': self.activation_key, 'to': self.user.email} msg = UserSignIn(email_context, self.user.email) msg.send()
def send_email(self, email=None, site=None, request=None): """ Send invitation email. Both ``email`` and ``site`` parameters are optional. If not supplied instance's ``email`` field and current site will be used. **Templates:** :studytribe/invitation/invitation_email_subject.txt: Template used to render the email subject. **Context:** :invitation: ``Invitation`` instance ``send_email`` is called on. :site: ``Site`` instance to be used. :studytribe/invitation/invitation_email_message.txt: Template used to render the email body. **Context:** :invitation: ``Invitation`` instance ``send_email`` is called on. :expiration_days: ``INVITATION_EXPIRE_DAYS`` setting. :site: ``Site`` instance to be used. **Signals:** ``invitation.signals.invitation_sent`` is sent on completion. """ email = email or self.email if site is None: if Site._meta.installed: site = Site.objects.get_current() elif request is not None: site = RequestSite(request) subject = render_to_string('studytribe/invitation/invitation_email_subject.txt', {'invitation': self, 'site': site}) # Email subject *must not* contain newlines subject = ''.join(subject.splitlines()) message = render_to_string('studytribe/invitation/invitation_email_message.txt', {'invitation': self, 'expiration_days': settings.INVITATION_EXPIRE_DAYS, 'site': site, 'protocol':get_protocol()}) send_mail(subject, message, settings.DEFAULT_FROM_EMAIL, [email]) signals.invitation_sent.send(sender=self)
def send_confirmation_email(self): """ Sends an email to confirm the new email address. This method sends out two emails. One to the new email address that contains the ``email_confirmation_key`` which is used to verify this this email address with :func:`UserenaUser.objects.confirm_email`. The other email is to the old email address to let the user know that a request is made to change this email address. """ context= {'user': self.user, 'without_usernames': userena_settings.USERENA_WITHOUT_USERNAMES, 'new_email': self.email_unconfirmed, 'protocol': get_protocol(), 'confirmation_key': self.email_confirmation_key, 'site': Site.objects.get_current()} # Email to the old address subject_old = render_to_string('userena/emails/confirmation_email_subject_old.txt', context) subject_old = ''.join(subject_old.splitlines()) message_old = render_to_string('userena/emails/confirmation_email_message_old.txt', context) try: send_mail(subject_old, message_old, settings.DEFAULT_FROM_EMAIL, [self.user.email]) except: pass # Email to the new address subject_new = render_to_string('userena/emails/confirmation_email_subject_new.txt', context) subject_new = ''.join(subject_new.splitlines()) message_new = render_to_string('userena/emails/confirmation_email_message_new.txt', context) send_mail(subject_new, message_new, settings.DEFAULT_FROM_EMAIL, [self.email_unconfirmed,])
def send_confirmation_email(self): """ Sends an email to confirm the new email address. This method sends out two emails. One to the new email address that contains the ``email_confirmation_key`` which is used to verify this this email address with :func:`UserenaUser.objects.confirm_email`. The other email is to the old email address to let the user know that a request is made to change this email address. """ context= {'user': self.user, 'without_usernames': userena_settings.USERENA_WITHOUT_USERNAMES, 'new_email': self.email_unconfirmed, 'protocol': get_protocol(), 'confirmation_key': self.email_confirmation_key, 'site': Site.objects.get_current()} # Email to the old address subject_old = render_to_string('userena/emails/confirmation_email_subject_old.txt', context) subject_old = ''.join(subject_old.splitlines()) message_old = render_to_string('userena/emails/confirmation_email_message_old.txt', context) send_mail(subject_old, message_old, settings.DEFAULT_FROM_EMAIL, [self.user.email]) # Email to the new address subject_new = render_to_string('userena/emails/confirmation_email_subject_new.txt', context) subject_new = ''.join(subject_new.splitlines()) message_new = render_to_string('userena/emails/confirmation_email_message_new.txt', context) send_mail(subject_new, message_new, settings.DEFAULT_FROM_EMAIL, [self.email_unconfirmed,])
def send_activation_email(self): """ Sends a activation email to the user. This email is send when the user wants to activate their newly created user. """ context = {'user': self.user, 'without_usernames': userena_settings.USERENA_WITHOUT_USERNAMES, 'protocol': get_protocol(), 'activation_days': userena_settings.USERENA_ACTIVATION_DAYS, 'activation_key': self.activation_key, 'site': Site.objects.get_current()} mailer = UserenaConfirmationMail(context=context) mailer.generate_mail("activation") mailer.send_mail(self.user.email)
def send_activation_email(self): """ Sends a activation email to the user. This email is send when the user wants to activate their newly created user. Override default userena mechanism, to send beautiful HTML email """ email_context = { 'user': self.user, 'without_usernames': userena_settings.USERENA_WITHOUT_USERNAMES, 'protocol': get_protocol(), 'activation_days': userena_settings.USERENA_ACTIVATION_DAYS, 'activation_key': self.activation_key, 'to': self.user.email } msg = UserSignIn(email_context, self.user.email) msg.send()
def handle(self, *args, **options): for email in args: if User.objects.filter(email__iexact=email): sys.stderr.write( "User with email %s already exists. Skipping.\n" % email) continue while True: username = hashlib.sha1(email).hexdigest()[:16] try: User.objects.get(username__iexact=username) except User.DoesNotExist: break # create user new_user = UserenaSignup.objects.create_user(username, email, None, active=False, send_email=False) # send activation email context = { 'user': new_user, 'without_usernames': userena_settings.USERENA_WITHOUT_USERNAMES, 'protocol': get_protocol(), 'activation_days': userena_settings.USERENA_ACTIVATION_DAYS, 'activation_key': new_user.userena_signup.activation_key, 'site': Site.objects.get_current() } subject = render_to_string('emails/activation_subject.txt', context) subject = ''.join(subject.splitlines()) body = render_to_string('emails/activation_body.txt', context) send_mail(subject, body, settings.DEFAULT_FROM_EMAIL, [ new_user.email, ]) self.stdout.write("Created user for %s\n" % email)
def send_activation_email(self): """ Sends a activation email to the user. This email is send when the user wants to activate their newly created user. """ context = { "user": self.user, "without_usernames": userena_settings.USERENA_WITHOUT_USERNAMES, "protocol": get_protocol(), "activation_days": userena_settings.USERENA_ACTIVATION_DAYS, "activation_key": self.activation_key, "site": shortcuts.get_current_site(request=None), } mailer = UserenaConfirmationMail(context=context) mailer.generate_mail("activation") mailer.send_mail(self.user.email)
def send_activation_email(self): """ Sends a activation email to the user. This email is send when the user wants to activate their newly created user. """ context = { "user": self.user, "protocol": get_protocol(), "activation_days": userena_settings.USERENA_ACTIVATION_DAYS, "activation_key": self.activation_key, "site": Site.objects.get_current(), } subject = render_to_string("userena/emails/activation_email_subject.txt", context) subject = "".join(subject.splitlines()) message = render_to_string("userena/emails/activation_email_message.txt", context) send_mail(subject, message, settings.DEFAULT_FROM_EMAIL, [self.user.email])
def send_registration_confirmation_email(self): context = {'user': self.user, 'without_usernames': userena_settings.USERENA_WITHOUT_USERNAMES, 'protocol': get_protocol(), 'site': Site.objects.get_current()} subject = render_to_string('profiles/emails/registration_confirm_subject.txt', context) subject = ''.join(subject.splitlines()) if (not userena_settings.USERENA_HTML_EMAIL or not message_old_html or userena_settings.USERENA_USE_PLAIN_TEMPLATE): message = render_to_string('profiles/emails/registration_confirm_message.txt', context) if self.user.email: send_mail(subject, message, None, settings.DEFAULT_FROM_EMAIL, [self.user.email])
def send_activated_email(self): """ Sends a activated email to the user. This email is send when a new user has been created and activated. """ context= {'user': self.user, 'protocol': get_protocol(), 'site': Site.objects.get_current()} subject = render_to_string('userena/emails/activated_email_subject.txt', context) subject = ''.join(subject.splitlines()) message = render_to_string('userena/emails/activated_email_message.txt', context) send_mail(subject, message, settings.DEFAULT_FROM_EMAIL, [self.user.email,])
def send_activation_email(self, **extra_context): """ Sends a activation email to the user. This email is send when the user wants to activate their newly created user. """ context = {'user': self.user, 'without_usernames': userena_settings.USERENA_WITHOUT_USERNAMES, 'protocol': get_protocol(), 'activation_days': userena_settings.USERENA_ACTIVATION_DAYS, 'activation_key': self.activation_key, 'site': Site.objects.get_current()} context.update(extra_context) subject = render_to_string('userena/emails/activation_email_subject.txt', context) subject = ''.join(subject.splitlines()) if userena_settings.USERENA_HTML_EMAIL: message_html = render_to_string('userena/emails/activation_email_message.html', context) else: message_html = None if (not userena_settings.USERENA_HTML_EMAIL or not message_html or userena_settings.USERENA_USE_PLAIN_TEMPLATE): message = render_to_string('userena/emails/activation_email_message.txt', context) else: message = None send_mail(subject, message, message_html, settings.DEFAULT_FROM_EMAIL, [self.user.email, ])
def send_approval_email(self): """ Sends an approval email to the user. This email is sent when USERENA_MODERATE_SIGNUP, after an admin has approved the signup. """ context= {'user': self.user, 'protocol': get_protocol(), 'site': Site.objects.get_current()} subject = render_to_string('userena/emails/approval_email_subject.txt', context) subject = ''.join(subject.splitlines()) message = render_to_string('userena/emails/approval_email_message.txt', context) send_mail(subject, message, settings.DEFAULT_FROM_EMAIL, [self.user.email,])
def send_message_notification(sender, instance, **kwargs): """ Send email when user receives a new message. This email contains the full text and a link to read it online. We trigger this when a MessageRecipient is saved and not when a Message is saved because umessages first saves a message and then adds its recipients, so when a Message is saved, it doesn't yet have a list of recipients. """ if not instance.user.email: # Email can be missing for users registered with Twitter # or LinkedIn return params = { 'sender': instance.message.sender.username, 'body': instance.message.body, } message_url_path = reverse('userena_umessages_detail', kwargs={'username': params['sender']}) params['message_url'] = "%s://%s%s" % ( get_protocol(), Site.objects.get_current(), message_url_path) subject = _( u'New message from %(sender)s on Imagination For People') % params message = render_to_string('umessages/message_notification.txt', params) recipient = instance.user.email # XXX Resets the Content-Transfer-Encoding in email header # Avoids bad encoding of UTF-8 body # See https://code.djangoproject.com/ticket/3472 from email import Charset Charset.add_charset('utf-8', Charset.SHORTEST, 'utf-8', 'utf-8') send_mail(subject, message, settings.DEFAULT_FROM_EMAIL, [recipient])
def test_get_protocol(self): """ Test if the correct protocol is returned """ self.assertEqual(get_protocol(), "http") with self.settings(USERENA_USE_HTTPS=True): self.assertEqual(get_protocol(), "https")
def test_get_protocol(self): """ Test if the correct protocol is returned """ self.failUnlessEqual(get_protocol(), 'http') with self.settings(USERENA_USE_HTTPS=True): self.failUnlessEqual(get_protocol(), 'https')
def test_get_protocol(self): """ Test if the correct protocol is returned """ self.failUnlessEqual(get_protocol(), 'http') with self.settings(USERENA_USE_HTTPS=True): self.failUnlessEqual(get_protocol(), 'https')