def send_foi_mail(subject, message, from_email, recipient_list,
attachments=None, fail_silently=False, **kwargs):
connection = get_connection(
backend=getattr(settings, 'FOI_EMAIL_BACKEND', settings.EMAIL_BACKEND),
username=settings.FOI_EMAIL_HOST_USER,
password=settings.FOI_EMAIL_HOST_PASSWORD,
host=settings.FOI_EMAIL_HOST,
port=settings.FOI_EMAIL_PORT,
use_tls=settings.FOI_EMAIL_USE_TLS,
fail_silently=fail_silently
)
headers = {}
if "message_id" in kwargs:
headers['Message-ID'] = kwargs.pop("message_id")
if settings.FOI_EMAIL_FIXED_FROM_ADDRESS:
name, mailaddr = parseaddr(from_email)
from_address = settings.FOI_EMAIL_HOST_FROM
from_email = make_address(from_address, name)
headers['Reply-To'] = make_address(mailaddr, name)
else:
headers['Reply-To'] = from_email
email = EmailMessage(subject, message, from_email, recipient_list,
connection=connection, headers=headers)
if attachments is not None:
for name, data, mime_type in attachments:
email.attach(name, data, mime_type)
return email.send()
def send_foi_mail(subject,
message,
from_email,
recipient_list,
fail_silently=False,
**kwargs):
connection = get_connection(username=settings.FOI_EMAIL_HOST_USER,
password=settings.FOI_EMAIL_HOST_PASSWORD,
host=settings.FOI_EMAIL_HOST,
port=settings.FOI_EMAIL_PORT,
use_tls=settings.FOI_EMAIL_USE_TLS,
fail_silently=fail_silently)
headers = {}
if "message_id" in kwargs:
headers['Message-ID'] = kwargs.pop("message_id")
if settings.FOI_EMAIL_FIXED_FROM_ADDRESS:
name, mailaddr = parseaddr(from_email)
from_address = settings.FOI_EMAIL_HOST_FROM
from_email = make_address(from_address, name)
headers['Reply-To'] = make_address(mailaddr, name)
else:
headers['Reply-To'] = from_email
email = EmailMessage(subject,
message,
from_email,
recipient_list,
connection=connection,
headers=headers)
return email.send()
def send_foi_mail(subject,
message,
from_email,
recipient_list,
attachments=None,
fail_silently=False,
**kwargs):
connection = get_connection(backend=getattr(settings, 'FOI_EMAIL_BACKEND',
settings.EMAIL_BACKEND),
username=settings.FOI_EMAIL_HOST_USER,
password=settings.FOI_EMAIL_HOST_PASSWORD,
host=settings.FOI_EMAIL_HOST,
port=settings.FOI_EMAIL_PORT,
use_tls=settings.FOI_EMAIL_USE_TLS,
fail_silently=fail_silently)
headers = {}
if "message_id" in kwargs:
headers['Message-ID'] = kwargs.pop("message_id")
if settings.FOI_EMAIL_FIXED_FROM_ADDRESS:
name, mailaddr = parseaddr(from_email)
from_address = settings.FOI_EMAIL_HOST_FROM
from_email = make_address(from_address, name)
headers['Reply-To'] = make_address(mailaddr, name)
else:
headers['Reply-To'] = from_email
email = EmailMessage(subject,
message,
from_email,
recipient_list,
connection=connection,
headers=headers)
if attachments is not None:
for name, data, mime_type in attachments:
email.attach(name, data, mime_type)
return email.send()
def get_text_recipient(self):
if not self.is_response:
alternative = self.recipient
if self.recipient_public_body:
alternative = self.recipient_public_body.name
if self.is_postal:
return _('{} (via post)').format(self.recipient or alternative)
return make_address(self.recipient_email, self.recipient
or alternative)
recipient = self.recipient or self.request.user.get_full_name()
if self.is_postal:
return _('{} (via post)').format(recipient)
email = self.recipient_email or self.request.secret_address
return make_address(email, recipient)
def send_message(self, subscription):
context = get_email_context(subscription, submission=self)
subject = self.message.subject_template.render(context).strip()
body = self.message.text_template.render(context)
extra_kwargs = {'queue': settings.EMAIL_BULK_QUEUE}
if self.message.html_template:
extra_kwargs['html'] = self.message.html_template.render(context)
try:
logger.debug(ugettext(u'Submitting message to: %s.'), subscription)
send_mail(subject,
body,
make_address(subscription.email, name=subscription.name),
from_email=self.newsletter.get_sender(),
unsubscribe_reference='{prefix}{pk}'.format(
prefix=REFERENCE_PREFIX, pk=subscription.id),
**extra_kwargs)
except Exception as e:
# TODO: Test coverage for this branch.
logger.error(
ugettext(u'Message %(subscription)s failed '
u'with error: %(error)s'), {
'subscription': subscription,
'error': e
})
def send_foi_mail(subject,
message,
from_email,
recipient_list,
attachments=None,
fail_silently=False,
**kwargs):
backend = None
if kwargs.get('dsn'):
if hasattr(settings, 'FOI_EMAIL_BACKEND'):
backend = settings.FOI_EMAIL_BACKEND
if not backend:
backend = settings.EMAIL_BACKEND
connection = get_connection(backend=backend,
username=settings.FOI_EMAIL_HOST_USER,
password=settings.FOI_EMAIL_HOST_PASSWORD,
host=settings.FOI_EMAIL_HOST,
port=settings.FOI_EMAIL_PORT,
use_tls=settings.FOI_EMAIL_USE_TLS,
fail_silently=fail_silently)
headers = {}
if settings.FOI_EMAIL_FIXED_FROM_ADDRESS:
name, mailaddr = parseaddr(from_email)
from_address = settings.FOI_EMAIL_HOST_FROM
from_email = make_address(from_address, name)
headers['Reply-To'] = make_address(mailaddr, name)
else:
headers['Reply-To'] = from_email
if kwargs.get('read_receipt'):
headers['Disposition-Notification-To'] = from_email
if kwargs.get('delivery_receipt'):
headers['Return-Receipt-To'] = from_email
if kwargs.get('froide_message_id'):
headers['X-Froide-Message-Id'] = kwargs.get('froide_message_id')
email = EmailMessage(subject,
message,
from_email,
recipient_list,
connection=connection,
headers=headers)
if attachments is not None:
for name, data, mime_type in attachments:
email.attach(name, data, mime_type)
return email.send()
def get_text_recipient(self):
if not self.is_response:
alternative = self.recipient
if self.recipient_public_body:
alternative = self.recipient_public_body.name
if self.is_not_email:
return _('{name} (via {via})').format(
name=self.recipient or alternative,
via=self.get_kind_display())
return make_address(self.recipient_email, self.recipient
or alternative)
recipient = self.recipient or self.request.user.get_full_name()
if self.is_not_email:
return _('{name} (via {via})').format(name=recipient,
via=self.get_kind_display())
email = self.recipient_email or self.request.secret_address
return make_address(email, recipient)
def real_sender(self):
if self.sender_user:
return self.sender_user.get_profile().display_name
if settings.FROIDE_CONFIG.get("public_body_officials_email_public",
False):
return make_address(self.sender_email, self.sender_name)
if self.sender_name:
return self.sender_name
else:
return self.sender_public_body.name
def run_send(self, **kwargs):
message = self.message
request = message.request
attachments = kwargs.get('attachments', [])
extra_kwargs = {}
# Use send_foi_mail here
from_addr = make_address(
request.secret_address,
'{} [#{}]'.format(
request.user.get_full_name(),
request.id
)
)
get_notified = (
message.sender_user and
message.sender_user.is_superuser and
not request.public
)
if settings.FROIDE_CONFIG['read_receipt'] and get_notified:
extra_kwargs['read_receipt'] = True
if settings.FROIDE_CONFIG['delivery_receipt'] and get_notified:
extra_kwargs['delivery_receipt'] = True
if settings.FROIDE_CONFIG['dsn'] and get_notified:
extra_kwargs['dsn'] = True
message.timestamp = timezone.now()
message.save()
message_id = message.get_absolute_domain_short_url()
extra_kwargs['froide_message_id'] = message_id
send_foi_mail(
message.subject, message.plaintext, from_addr,
[message.recipient_email.strip()],
attachments=attachments,
**extra_kwargs
)
message.email_message_id = ''
message.sent = True
message.save()
DeliveryStatus.objects.update_or_create(
message=message,
defaults=dict(
status=DeliveryStatus.STATUS_SENDING,
last_update=timezone.now(),
)
)
# Check delivery status in 2 minutes
from .tasks import check_delivery_status
check_delivery_status.apply_async((message.id,), {'count': 0},
countdown=2 * 60)
def send(self):
if settings.FROIDE_DRYRUN:
recp = self.recipient.replace("@", "+")
self.recipient = "%s@%s" % (recp, settings.FROIDE_DRYRUN_DOMAIN)
# Use send_foi_mail here
from_addr = make_address(self.request.secret_address,
self.request.user.get_full_name())
send_foi_mail(self.subject, self.plaintext, from_addr, [self.recipient])
self.sent = True
self.save()
FoiRequest.message_sent.send(sender=self.request, message=self)
def send_foi_mail(subject, message, from_email, recipient_list,
fail_silently=False, **kwargs):
connection = get_connection(username=settings.FOI_EMAIL_HOST_USER,
password=settings.FOI_EMAIL_HOST_PASSWORD,
host=settings.FOI_EMAIL_HOST,
port=settings.FOI_EMAIL_PORT,
use_tls=settings.FOI_EMAIL_USE_TLS,
fail_silently=fail_silently)
headers = {}
if "message_id" in kwargs:
headers['Message-ID'] = kwargs.pop("message_id")
if settings.FOI_EMAIL_FIXED_FROM_ADDRESS:
name, mailaddr = parseaddr(from_email)
from_address = settings.FOI_EMAIL_HOST_FROM
from_email = make_address(from_address, name)
headers['Reply-To'] = make_address(mailaddr, name)
else:
headers['Reply-To'] = from_email
email = EmailMessage(subject, message, from_email, recipient_list,
connection=connection, headers=headers)
return email.send()
def user_real_sender(self):
if self.sender_user:
return self.sender_user.get_full_name()
if settings.FROIDE_CONFIG.get("public_body_officials_email_public",
False):
return make_address(self.sender_email, self.sender_name)
if self.sender_name:
return self.sender_name
else:
if self.sender_public_body:
return self.sender_public_body.name
return self.sender_public_body
def user_real_sender(self):
if self.sender_user:
return self.sender_user.get_full_name()
if settings.FROIDE_CONFIG.get(
"public_body_officials_email_public", False):
return make_address(self.sender_email, self.sender_name)
if self.sender_name:
return self.sender_name
else:
if self.sender_public_body:
return self.sender_public_body.name
return self.sender_public_body
def get_text_recipient(self):
if not self.is_response:
alternative = self.recipient
if self.recipient_public_body:
alternative = self.recipient_public_body.name
if self.is_not_email:
return _('{name} (via {via})').format(
name=self.recipient or alternative,
via=self.get_kind_display()
)
return make_address(self.recipient_email,
self.recipient or alternative)
recipient = self.recipient or self.request.user.get_full_name()
if self.is_not_email:
return _('{name} (via {via})').format(
name=recipient,
via=self.get_kind_display()
)
email = self.recipient_email or self.request.secret_address
return make_address(email, recipient)
def send_foi_mail(subject, message, from_email, recipient_list,
attachments=None, fail_silently=False, **kwargs):
backend_kwargs = {}
if kwargs.get('dsn'):
backend_kwargs['rcpt_options'] = DSN_RCPT_OPTIONS
connection = get_connection(
backend=settings.EMAIL_BACKEND,
username=settings.FOI_EMAIL_HOST_USER,
password=settings.FOI_EMAIL_HOST_PASSWORD,
host=settings.FOI_EMAIL_HOST,
port=settings.FOI_EMAIL_PORT,
use_tls=settings.FOI_EMAIL_USE_TLS,
fail_silently=fail_silently,
**backend_kwargs
)
headers = {}
if settings.FOI_EMAIL_FIXED_FROM_ADDRESS:
name, mailaddr = parseaddr(from_email)
from_address = settings.FOI_EMAIL_HOST_FROM
from_email = make_address(from_address, name)
headers['Reply-To'] = make_address(mailaddr, name)
else:
headers['Reply-To'] = from_email
if kwargs.get('read_receipt'):
headers['Disposition-Notification-To'] = from_email
if kwargs.get('delivery_receipt'):
headers['Return-Receipt-To'] = from_email
if kwargs.get('froide_message_id'):
headers['X-Froide-Message-Id'] = kwargs.get('froide_message_id')
email = EmailMessage(subject, message, from_email, recipient_list,
connection=connection, headers=headers)
if attachments is not None:
for name, data, mime_type in attachments:
email.attach(name, data, mime_type)
return email.send()
def send(self, notify=True, attachments=None):
if settings.FROIDE_CONFIG['dryrun']:
recp = self.recipient_email.replace("@", "+")
self.recipient_email = "%s@%s" % (
recp, settings.FROIDE_CONFIG['dryrun_domain'])
# Use send_foi_mail here
from_addr = make_address(self.request.secret_address,
self.request.user.get_full_name())
if not self.request.is_blocked:
send_foi_mail(self.subject,
self.plaintext,
from_addr, [self.recipient_email.strip()],
attachments=attachments)
self.sent = True
self.save()
self.request._messages = None
if notify:
FoiRequest.message_sent.send(sender=self.request, message=self)
def run_send(self, notify=True, **kwargs):
message = self.message
request = message.request
attachments = kwargs.get('attachments', [])
extra_kwargs = {}
if settings.FROIDE_CONFIG['dryrun']:
recp = message.recipient_email.replace("@", "+")
message.recipient_email = "%s@%s" % (
recp, settings.FROIDE_CONFIG['dryrun_domain'])
# Use send_foi_mail here
from_addr = make_address(request.secret_address,
request.user.get_full_name())
get_notified = (message.sender_user.is_superuser
and not request.public)
if settings.FROIDE_CONFIG['read_receipt'] and get_notified:
extra_kwargs['read_receipt'] = True
if settings.FROIDE_CONFIG['delivery_receipt'] and get_notified:
extra_kwargs['delivery_receipt'] = True
if settings.FROIDE_CONFIG['dsn'] and get_notified:
extra_kwargs['dsn'] = True
message.save()
message_id = message.get_absolute_domain_short_url()
extra_kwargs['froide_message_id'] = message_id
attachments.extend([(a.name, a.get_bytes(), a.filetype)
for a in message.attachments])
send_foi_mail(message.subject,
message.plaintext,
from_addr, [message.recipient_email.strip()],
attachments=attachments,
**extra_kwargs)
message.email_message_id = ''
message.sent = True
message.save()
# Check delivery status in 2 minutes
from .tasks import check_delivery_status
check_delivery_status.apply_async((message.id, ), {'count': 0},
countdown=2 * 60)
def send(self, notify=True, attachments=None):
extra_kwargs = {}
if settings.FROIDE_CONFIG['dryrun']:
recp = self.recipient_email.replace("@", "+")
self.recipient_email = "%s@%s" % (
recp, settings.FROIDE_CONFIG['dryrun_domain'])
# Use send_foi_mail here
from_addr = make_address(self.request.secret_address,
self.request.user.get_full_name())
get_notified = (self.sender_user.is_superuser
and not self.request.public)
if settings.FROIDE_CONFIG['read_receipt'] and get_notified:
extra_kwargs['read_receipt'] = True
if settings.FROIDE_CONFIG['delivery_receipt'] and get_notified:
extra_kwargs['delivery_receipt'] = True
if settings.FROIDE_CONFIG['dsn'] and get_notified:
extra_kwargs['dsn'] = True
self.save()
message_id = self.get_absolute_domain_short_url()
extra_kwargs['froide_message_id'] = message_id
if not self.request.is_blocked:
send_foi_mail(self.subject,
self.plaintext,
from_addr, [self.recipient_email.strip()],
attachments=attachments,
**extra_kwargs)
self.email_message_id = ''
self.sent = True
self.save()
ds = self.get_delivery_status()
if ds is not None:
ds.delete()
# Check delivery status in 2 minutes
from ..tasks import check_delivery_status
check_delivery_status.apply_async((self.id, ), {'count': 0},
countdown=2 * 60)
self.request._messages = None
if notify:
FoiRequest.message_sent.send(sender=self.request, message=self)
def run_send(self, notify=True, **kwargs):
message = self.message
request = message.request
attachments = kwargs.get('attachments', [])
extra_kwargs = {}
# Use send_foi_mail here
from_addr = make_address(
request.secret_address,
'{} [#{}]'.format(
request.user.get_full_name(),
request.id
)
)
get_notified = (message.sender_user.is_superuser and
not request.public)
if settings.FROIDE_CONFIG['read_receipt'] and get_notified:
extra_kwargs['read_receipt'] = True
if settings.FROIDE_CONFIG['delivery_receipt'] and get_notified:
extra_kwargs['delivery_receipt'] = True
if settings.FROIDE_CONFIG['dsn'] and get_notified:
extra_kwargs['dsn'] = True
message.save()
message_id = message.get_absolute_domain_short_url()
extra_kwargs['froide_message_id'] = message_id
send_foi_mail(
message.subject, message.plaintext, from_addr,
[message.recipient_email.strip()],
attachments=attachments,
**extra_kwargs
)
message.email_message_id = ''
message.sent = True
message.save()
# Check delivery status in 2 minutes
from .tasks import check_delivery_status
check_delivery_status.apply_async((message.id,), {'count': 0},
countdown=2 * 60)
def send_message(self, mailing_context=None, email_template=None):
assert self.sent is None
if not self.email:
self.delete()
return
context = self.get_email_context()
if mailing_context is not None:
context.update(mailing_context)
if email_template is None:
email_template = self.mailing.email_template
email_content = email_template.get_email_content(context)
extra_kwargs = {
'queue': settings.EMAIL_BULK_QUEUE
}
if email_content.html:
extra_kwargs['html'] = email_content.html
unsubscribe_reference = context.get('unsubscribe_reference')
try:
logger.debug('Sending mailing message to: %s.', self)
send_mail(email_content.subject, email_content.text,
make_address(self.email, name=self.name),
from_email=self.mailing.get_sender(),
unsubscribe_reference=unsubscribe_reference,
**extra_kwargs
)
self.sent = timezone.now()
self.save()
except Exception as e:
logger.error(
'Mailing message %s failed with error: %s' % (self, e)
)
def get_sender(self):
return make_address(self.sender_email, name=self.sender_name)
