class MultipleSMTPEmailBackend(BaseEmailBackend): def __init__(self, host=None, fail_silently=False, **kwargs): super(MultipleSMTPEmailBackend, self).__init__(fail_silently=fail_silently) self.bulk = SMTPEmailBackend(host=settings.EMAIL_HOST['bulk']['host'], port=settings.EMAIL_HOST['bulk']['port'], fail_silently=fail_silently, **kwargs) self.transactional = SMTPEmailBackend(host=settings.EMAIL_HOST['transactional']['host'], port=settings.EMAIL_HOST['transactional']['port'], fail_silently=fail_silently, **kwargs) def open(self): return self.bulk.open() and self.transactional.open() def close(self): self.bulk.close() self.transactional.close() def split_messages(self, email_messages): """Split messages list to send in 2 groups regarding their from_email field.""" bulk, transactional = [], [] for message in email_messages: from_email = sanitize_address(message.from_email, message.encoding) if settings.BULK_EMAIL_DEFAULT_FROM_EMAIL in from_email: bulk.append(message) else: transactional.append(message) return bulk, transactional def send_messages(self, email_messages): bulk_messages, transactional_messages = self.split_messages(email_messages) return ((self.bulk.send_messages(bulk_messages) or 0) + (self.transactional.send_messages(transactional_messages) or 0))
def recruiters(request): from social.forms import RecruiterInterestForm # check to see if email submitted if request.POST: form = RecruiterInterestForm(request.POST) # validate form if form.is_valid(): from django.core.mail.backends.smtp import EmailBackend from django.core.mail import EmailMultiAlternatives backend = EmailBackend() msg = EmailMultiAlternatives("ProsperMe: New recruiter signup","New signup: " + form.cleaned_data['email'],"*****@*****.**",["*****@*****.**"]) try: backend.send_messages([msg]) logger.info("New recruiter added: "+form.cleaned_data['email']) except: logger.error("Failed to email new recruiter: "+form.cleaned_data['email']) return HttpResponseRedirect("/recruiters/thanks/") else: form = RecruiterInterestForm() return render_to_response("recruiters.html",{'form':form},context_instance=RequestContext(request))
def myView(request): try: backend = EmailBackend( host='EMAIL_HOST', # Port 587 recomended for SMTP port=587, username='******', password='******', use_tls=True ) backend.open() subject = 'My subject' ''' If you want html message can do: from django.template.loader import render_to_string message = render_to_string('template.html') ''' message = 'Hi!' sender = '*****@*****.**' # List of recipients recipients = ['*****@*****.**'] email = EmailMessage(subject, message, sender, recipients) email.content_subtype = "html" backend.send_messages([email]) backend.close() except Exception,e: print(e) return render(request, "error.html")
class EmailBackend(BaseEmailBackend): def __init__(self, *args, **kwargs): self._smtpBackend = SmtpEmailBackend(*args, **kwargs) self._consoleBackend = ConsoleEmailBackend(*args, **kwargs) super().__init__(**kwargs) def send_messages(self, email_messages): self._smtpBackend.send_messages(email_messages) if settings.DEBUG: self._consoleBackend.send_messages(email_messages)
def send_mail(subject, body): try: mailob = AlertMailModel.objects.first() con = mail.get_connection(host=mailob.host_smtpaddress, port=mailob.port, fail_silently=False) try: con.open() print('Django connected to the SMTP server') except Exception as e: print(e.errno, e.strerror) ferob = Fernet(settings.FERNET_SECRET_KEY) # host = 'smtp.gmail.com' # host_user = '******' # host_pass = '******' # host_port = 587 host = mailob.host_smtpaddress host_user = mailob.host_mail host_pass = ferob.decrypt(mailob.mail_host_password.encode()).decode() host_port = mailob.port tls = mailob.use_tls mail_obj = EmailBackend(host=host, port=host_port, password=host_pass, username=host_user, use_tls=True, timeout=10) msg = mail.EmailMultiAlternatives( subject=subject, body=strip_tags(body), from_email=host_user, to=[mailob.receipient_mail], connection=con, ) msg.attach_alternative(body, "text/html") mail_obj.send_messages([msg]) print('Message has been sent.') mail_obj.close() print('SMTP server closed') return True except Exception as _error: print(_error) print('Error in sending mail >> {} {}'.format( str(_error.smtp_code), _error.smtp_code.decode())) return False
class BaseMailer(): def __init__(self, message_to, context, subject, template, sndr_host, sndr_username, sndr_pass, sndr_port, sndr_tls, **substitutions): self.con = mail.get_connection() self.message_to = message_to self.subject = subject self.body_msg = render_to_string(template, context) self.sndr_host = sndr_host self.sndr_port = sndr_port self.sndr_username = sndr_username self.sndr_pass = sndr_pass self.sndr_tls = sndr_tls # sth like request o algo asi xd self.substitutions = {} for key in substitutions: self.substitutions.update({key: substitutions[key]}) def create_email(self): # creating connection self.con.open() #filling the connection (EmailBackend) object self.mail_obj = EmailBackend(host=self.sndr_host, port=self.sndr_port, username=self.sndr_username, password=self.sndr_pass, use_tls=self.sndr_tls) # filling the EmailMessage object self.mail = mail.EmailMessage(subject=self.subject, body=self.body_msg, from_email=self.sndr_username, to=[self.message_to], connection=self.con) def send_email(self): self.create_email() try: self.mail.content_subtype = 'html' # self.con.send_messages([self.mail]) #sending email with the current connection, this is intended to send messages to multiple mails w/ the same conn # self.mail.send(self.mail) #sending email with the EmailMessage object self.mail_obj.send_messages([self.mail ]) #sending email with EmailBackend self.con.close() return True except Exception as e: print(f'\n\n# --- PY: Error sending email: --- #\n{e}') return False
def send_messages(self, email_messages): """ Intercept emails originating from SERVER_EMAIL and send them through SMTPBackend to notify ADMINS. """ server_email = getattr(settings, 'SERVER_EMAIL', None) admin_messages = filter(lambda x: x.from_email == server_email, email_messages) if admin_messages: smtp_backend = SMTPBackend() smtp_backend.send_messages(admin_messages) return super(DevEmailBackend, self).send_messages(email_messages)
class DevEmailBackend: """ Custom mail backend that uses MailCatcher but falls back to console if MailCatcher server is not running. Your dev settings should include the following to work with MailCatcher. EMAIL_HOST = '127.0.0.1' EMAIL_PORT = 1025 """ def __init__(self, *args, **kwargs): self.email_backend = DjangoEmailBackend(*args, **kwargs) self.console_backend = DjangoConsoleBackend(*args, **kwargs) def send_messages(self, email_messages): try: return self.email_backend.send_messages(email_messages) except Exception: return self.console_backend.send_messages(email_messages) def open(self): """ Stub method that allows the Wagtail backend to not fatal error when it's trying to send emails, such as moderation emails. """ pass def close(self): """ Stub method that allows the Wagtail backend to not fatal error when it's trying to send emails, such as moderation emails. """ pass
class EmailBackend(SmtpEmailBackend): def __init__(self, *args, **kwargs): fail_silently = kwargs.pop('fail_silently', False) kwargs['fail_silently'] = False super(EmailBackend, self).__init__(*args, **kwargs) kwargs['fail_silently'] = fail_silently host = getattr(settings, 'ALTERNATIVE_EMAIL_HOST', None) port = getattr(settings, 'ALTERNATIVE_EMAIL_PORT', None) if host is not None and port is not None: kwargs['username'] = getattr(settings, 'ALTERNATIVE_EMAIL_HOST_USER', self.username) kwargs['password'] = getattr(settings, 'ALTERNATIVE_EMAIL_HOST_PASSWORD', self.password) kwargs['use_tls'] = getattr(settings, 'ALTERNATIVE_EMAIL_USE_TLS', self.use_tls) self._alternative_backend = SmtpEmailBackend(host=host, port=port, **kwargs) else: self._alternative_backend = None def send_messages(self, email_messages): try: return super(EmailBackend, self).send_messages(email_messages) except Exception as e: if self._alternative_backend: return self._alternative_backend.send_messages(email_messages) else: raise e
class EmailBackend(SmtpEmailBackend): def __init__(self, *args, **kwargs): fail_silently = kwargs.pop('fail_silently', False) kwargs['fail_silently'] = False super(EmailBackend, self).__init__(*args, **kwargs) kwargs['fail_silently'] = fail_silently host = getattr(settings, 'ALTERNATIVE_EMAIL_HOST', None) port = getattr(settings, 'ALTERNATIVE_EMAIL_PORT', None) if host is not None and port is not None: kwargs['username'] = getattr(settings, 'ALTERNATIVE_EMAIL_HOST_USER', self.username) kwargs['password'] = getattr(settings, 'ALTERNATIVE_EMAIL_HOST_PASSWORD', self.password) kwargs['use_tls'] = getattr(settings, 'ALTERNATIVE_EMAIL_USE_TLS', self.use_tls) self._alternative_backend = SmtpEmailBackend( host=host, port=port, **kwargs ) else: self._alternative_backend = None def send_messages(self, email_messages): try: return super(EmailBackend, self).send_messages(email_messages) except Exception as e: if self._alternative_backend: return self._alternative_backend.send_messages(email_messages) else: raise e
def sending_mail(subject, message, contact_list): try: con = mail.get_connection() con.open() print('Django connected to the SMTP server') mail_setting = models.SmtpEmailSettings.objects.last() host = mail_setting.smtp_email_host host_user = mail_setting.smtp_email_host_user host_pass = mail_setting.smtp_email_host_password host_port = mail_setting.smtp_email_host_port host_sender_email = mail_setting.smtp_email_host_sender_address host_tls = mail_setting.smtp_use_tls host_ssl = mail_setting.smtp_use_ssl host_timeout = mail_setting.smtp_timeout mail_obj = EmailBackend(host=host, port=host_port, password=host_pass, username=host_user, use_tls=host_tls, use_ssl=host_ssl, timeout=host_timeout) msg = mail.EmailMessage( subject=subject, body=message, from_email=host_sender_email, to=[contact_list], connection=con, ) msg.content_subtype = "html" mail_obj.send_messages([msg]) print('Message has been sent.') mail_obj.close() print('SMTP server closed') return True except Exception as _error: print('Error in sending mail >> {}'.format(_error)) return False
class InternalOnlyBackend(object): def __init__(self, *args, **kwargs): self.file_backend = FileBackend(*args, **kwargs) self.smtp_backend = SmtpBackend(*args, **kwargs) self.white_listed_addresses = getattr(settings, "EMAIL_NOTIFICATION_RECEIVERS", []) def get_whitelisted(self, addresses): clean = [] for x in addresses: # addresses might be in form Name <email> start, end = x.find("<"), x.find(">") if start != -1 and end != -1: trimmed = x[start + 1:end] if trimmed in self.white_listed_addresses: clean.append(x) else: for white_listed in self.white_listed_addresses: if trimmed.endswith(white_listed): clean.append(x) break elif x in self.white_listed_addresses: clean.append(x) else: for white_listed in self.white_listed_addresses: if x.endswith(white_listed): clean.append(x) break return clean def send_messages(self, email_messages): try: self.file_backend.send_messages(email_messages) except: pass for message in email_messages: message.to = self.get_whitelisted(message.to) message.bcc = self.get_whitelisted(message.bcc) message.cc = self.get_whitelisted(message.cc) self.smtp_backend.send_messages(email_messages)
def send_single_html_mail(vector_email_id, fail_silently=False): try: vector_email = VectorEmail.objects.get(id=vector_email_id) except VectorEmail.DoesNotExist: # Prevents Celery log spam for the defunct task. ptask_identifier = 'send_vemail__v{}_'.format(vector_email_id) ptask = PeriodicTask.objects.get(name__contains=ptask_identifier) send_error_log_template = ('VE #{} not found while sending.' ' PeriodicTask #{}, {}, has been deleted.') logger.info( send_error_log_template.format(vector_email_id, ptask.id, ptask.name)) ptask.delete() raise Ignore() engagement = vector_email.engagement target = Target.objects.get(vector_email=vector_email) if vector_email.send_at_passed is True: vector_email.set_state(VectorEmail.SEND_MISSED) engagement.check_for_completion() send_missed_log_template = 'VE #{} send_at MISSED: {}, Target TZ {}' logger.info( send_missed_log_template.format(vector_email.id, vector_email.send_at, target.get_timezone())) return sending_log_template = 'Sending VE #{} with send_at {}, Target TZ {}' logger.info( sending_log_template.format(vector_email.id, vector_email.send_at, target.get_timezone())) email_server = engagement.email_server connection = EmailBackend(host=email_server.host, port=int(email_server.port), username=email_server.login, password=email_server.password, use_tls=email_server.use_tls) datatuple = generateContent(target, engagement) subject, text, html, from_email, recipient, from_address = datatuple message = EmailMultiAlternatives(subject, text, from_email, recipient, headers={'Reply-To': from_address}) message.attach_alternative(html, 'text/html') sent = 0 try: sent = connection.send_messages((message, )) server_tz = dj_tz.get_default_timezone() server_now = server_tz.localize(datetime.datetime.now()) vector_email.sent_timestamp = server_now vector_email.error = '' vector_email.save() vector_email.set_state(VectorEmail.SENT) engagement.check_for_completion() except Exception as e: vector_email.set_state(VectorEmail.ERROR) vector_email.error = interpret_email_error(e) vector_email.save() engagement.set_state(Engagement.ERROR) send_error_log_template = 'VE #{} task had an error: {}' logger.info(send_error_log_template.format(vector_email.id, e)) raise Ignore() return sent
class BaseMassiveMailer(): def __init__(self, message_to, context, subject, template, sndr_host, sndr_username, sndr_pass, sndr_port, sndr_tls, **substitutions): self.con = mail.get_connection() self.subject = subject self.message_to = message_to #A list of emails self.template = template self.context = context self.sndr_host = sndr_host self.sndr_port = sndr_port self.sndr_username = sndr_username self.sndr_pass = sndr_pass self.sndr_tls = sndr_tls self.substitutions = {} for key in substitutions: self.substitutions.update({key: substitutions[key]}) def create_emails(self): # creating connection self.con.open() #filling the connection (EmailBackend) object self.mail_obj = EmailBackend(host=self.sndr_host, port=self.sndr_port, username=self.sndr_username, password=self.sndr_pass, use_tls=self.sndr_tls) self.mails = [] # filling the EmailMessage objects for email in self.message_to: for k, v in self.context.items(): if k == email: ctxt = { 'email': k, 'unsubscribe_url': v, 'index_url': self.substitutions["index_url"], 'post_title': self.substitutions["post_title"], 'post_url': self.substitutions["post_url"], 'post_preview': self.substitutions["post_preview"], 'post_bg_img': self.substitutions["post_bg_img"], 'privacy_url': self.substitutions["privacy_url"], } body_msg = render_to_string(self.template, ctxt) new_mail_msg = mail.EmailMessage( subject=self.subject, body=body_msg, from_email=self.sndr_username, to=[email], connection=self.con) self.mails.append(new_mail_msg) def send_massive_email(self): self.create_emails() try: for mail in self.mails: mail.content_subtype = 'html' self.mail_obj.send_messages(self.mails) self.con.close() return True except Exception as e: print(f'\n\n# --- PY: Error sending massive emails: --- #\n{e}') return False