def post(self,request,*args,**kwargs):
error = None
success = None
form = CustomerRegistrationForm(request.POST)
#password = request.POST['password']
#email = request.POST['email']
if form.is_valid():
#form = CustomerRegistrationForm()
#Send verification code to user to activate account
try:
data = form.cleaned_data
password = data['password']
email = data['email']
user = form.save(commit=False)
user.set_password(password)
user.save()
email = email.strip()
user = Customer.objects.get_verify_code(email)
context = {'user': user, 'SITE_NAME': settings.SITE_NAME, 'DOMAIN': settings.DOMAIN}
print(context)
msg_subject = 'Activate Account'
text_content = render_to_string("accounts/email/email_signup_confirm.txt",context)
to_email = '%s <%s>' % (user.get_full_name(),user)
html_content = render_to_string('accounts/email/email_signup_confirm.html', context)
msg = EmailMultiAlternatives(msg_subject, text_content)
msg.attach_alternative(html_content, "text/html")
msg.from_email = '*****@*****.**'
msg.to = [to_email]
# Send a notification copy to admin
text_content2 = render_to_string("accounts/email/admin_notify.txt",context)
html_content2 = render_to_string('accounts/email/admin_notify.html', context)
msg_copy = EmailMultiAlternatives("New Customer Registration", text_content2)
msg_copy.attach_alternative(html_content2, "text/html")
msg_copy.to = ['*****@*****.**']
msg_copy.from_email = '*****@*****.**'
msg.send()
msg_copy.send()
return HttpResponseRedirect('/accounts/register_complete/')
except ValidationError as e:
error = e.message
return super(RegisterView,self).get(request,form=form,success=success,error=error)
def send_order_confirmation(self, order_number, total, lineitems,
customer):
"""Sends email to user confirming order and contents"""
items = []
for mydict in lineitems:
product_id = CustomerPrice.objects.get(id=mydict['product_id'])
items.append({
'product': product_id.product,
'price': mydict['price'],
'quantity': mydict['quantity'],
'sub_total': mydict['line_total']
})
context = {
'user': customer.last_name,
'order_items': items,
'order_number': order_number,
'total': total,
#'order_status':order_status,
'MEDIA_URL': settings.MEDIA_URL,
'SITE_URL': settings.SITE_URL
}
subject = 'Thanks for your purchase at Gaea! Order ' + str(
order_number)
from_email = 'Sales gaeafoods <*****@*****.**>'
# If at order screen, user provided an email address
to = customer
text_content = render_to_string('orders/email/order_confirmation.txt',
context)
html_content = render_to_string('orders/email/order_confirmation.html',
context)
msg = EmailMultiAlternatives(subject, text_content)
msg.attach_alternative(html_content, "text/html")
msg.to = [to]
msg.from_email = from_email
# Send a copy to me after finished as well
msg_copy = EmailMultiAlternatives(
"#Order " + str(order_number) + '--' + str(customer.company),
text_content)
msg_copy.attach_alternative(html_content, "text/html")
msg_copy.to = ['*****@*****.**']
msg_copy.from_email = from_email
msg.send()
msg_copy.send()
def add_bounce_sender_global(sender, message: EmailMultiAlternatives, order,
user, customer, **kwargs):
if not settings.CONFIG_FILE.has_section('bounces') or order:
return message
from_domain = settings.CONFIG_FILE.get('bounces',
'from_domain',
fallback='')
if from_domain and '@' + from_domain not in message.from_email:
return message
if user:
alias = generate_new_user_alias(user)
elif customer:
alias = generate_new_customer_alias(customer)
else:
return message
from_email = message.from_email
if 'Reply-To' not in message.extra_headers:
message.extra_headers['Reply-To'] = from_email
message.from_email = alias
message.extra_headers.update({'From': from_email, 'Sender': alias})
return message
def send_message(self,
recipients: List[str],
subject: str,
template: str = None,
template_context: dict = None,
from_address: str = None,
text: str = None,
**kwargs):
"""Send emails in the background. For each recipient a new E-Mail is generated.
Args:
recipients: List of E-Mail addresses we send to.
subject: Subject of E-Mail.
template: Optional path to a django template.
This template is rendered and attached as text/html multipart
template_context: Optional conext for template above.
from_address: Optional Address we send E-Mail addresses from.
If not given, we use the default from Settings
text: Optional plaintext for the body
"""
self.prepare(**kwargs)
emails = []
# If we don't have text and template, return now.
if not text and not template:
raise ValueError("Either text or template must be supplied.")
for recipient in recipients:
# Create a separate email for each recipient
email = EmailMultiAlternatives()
email.from_email = from_address if from_address else settings.EMAIL_FROM
email.body = text if text else ''
email.to = [recipient]
email.subject = subject
if template:
_template = loader.get_template(template)
context = template_context if template_context else {}
# Lookup user from recipient address, to give it to the template
users = User.objects.filter(email=recipient)
if users.exists():
context['_user'] = users.first()
# If debug is disabled, minify HTML to save bandwidth
html = _template.render(context)
if not settings.DEBUG:
html = html_minify(html)
email.attach_alternative(html, 'text/html')
LOGGER.debug("Prepared E-Mail '%s' to %s", subject, recipient)
emails.append(email)
try:
with get_connection() as connection:
sent = connection.send_messages(emails)
return sent == len(
emails) # send_messages returns amount of emails sent
except SMTPException as exc:
# Always return true when debugging
if settings.DEBUG:
LOGGER.warning("Failed to send emails %r", exc)
return True
raise
def send(self):
#Create the weekmail content and send it.
html_parser = html.parser.HTMLParser()
content = {'weekmail': html_parser.unescape(self)}
mail_content_txt = render_to_string('communication/weekmail.txt',
content)
mail_content_html = render_to_string('communication/weekmail.html',
content)
#You can change the weekmail recipients here.
recipients = settings.WEEKMAIL_RECIPIENTS
sender = settings.DEFAULT_FROM_EMAIL
try:
mail = EmailMultiAlternatives()
mail.subject = _('[Weekmail] %s') % (self.subject)
mail.body = mail_content_txt
mail.from_email = sender
mail.to = recipients
mail.cc = [sender,]
mail.attach_alternative(mail_content_html, "text/html")
for attachment in self.attached.all():
mail.attach_file(attachment.file.path)
mail.send()
self.sent_date = timezone.now()
self.save()
return True
except SMTPException:
return False
return False
def send_mail(self: MonitoredTask,
message: dict[Any, Any],
email_stage_pk: Optional[int] = None):
"""Send Email for Email Stage. Retries are scheduled automatically."""
self.save_on_success = False
message_id = make_msgid(domain=DNS_NAME)
self.set_uid(slugify(message_id.replace(".", "_").replace("@", "_")))
try:
if not email_stage_pk:
stage: EmailStage = EmailStage(use_global_settings=True)
else:
stage: EmailStage = EmailStage.objects.get(pk=email_stage_pk)
backend = stage.backend
backend.open()
# Since django's EmailMessage objects are not JSON serialisable,
# we need to rebuild them from a dict
message_object = EmailMultiAlternatives()
for key, value in message.items():
setattr(message_object, key, value)
if not stage.use_global_settings:
message_object.from_email = stage.from_address
# Because we use the Message-ID as UID for the task, manually assign it
message_object.extra_headers["Message-ID"] = message_id
LOGGER.debug("Sending mail", to=message_object.to)
stage.backend.send_messages([message_object])
self.set_status(
TaskResult(
TaskResultStatus.SUCCESSFUL,
messages=["Successfully sent Mail."],
))
except (SMTPException, ConnectionError) as exc:
LOGGER.debug("Error sending email, retrying...", exc=exc)
self.set_status(TaskResult(TaskResultStatus.ERROR).with_error(exc))
raise exc
def send_14d_comeback_email(self, membership):
email = EmailMultiAlternatives()
email.subject = "We want you back!"
email.to = [membership.user.email]
email.bcc = [settings.MEMBERSHIP_GROUP_EMAIL]
email.from_email = settings.MEMBERSHIP_GROUP_EMAIL
content = {
"user":
membership.user,
"email_body":
AutoGeneratedEmail.objects.get(
email_title='comeback_email').email_body
}
plaintext_template = get_template(
'accounts/emails/renewal_email_comeback.txt')
plaintext_message = plaintext_template.render(Context(content))
html_template = get_template(
'accounts/emails/renewal_email_comeback.html')
html_message = html_template.render(Context(content))
#send plaintext and html version
email.attach_alternative(html_message, "text/html")
email.send(fail_silently=False)
def send_email(to, subject, message_text, message_html=None, sender=settings.DEFAULT_FROM_EMAIL):
email = EmailMultiAlternatives(subject, message_text)
if message_html:
email.attach_alternative(message_html, "text/html")
email.to = [to]
email.from_email = sender
email.send()
def sendMail(self, mailFrom='*****@*****.**', mailTo=None, mailCC=None, mailBCC=None, replyTo=None, subject=None, bodyHTML=None, bodyText=None):
surpress = (EmailSuppression.objects.filter(suppression_date=date.today()).count() > 0)
if surpress:
log.warn("Surpressing e-mail")
return
if bodyText and bodyHTML:
message = EmailMultiAlternatives()
message.body = bodyText
message.attach_alternative(transform(bodyHTML), "text/html")
elif bodyText:
message = EmailMessage()
message.body = bodyText
elif bodyHTML:
message = EmailMessage()
message.body = transform(bodyHTML)
message.content_subtype = "html"
else:
raise TypeError("bodyHTML or bodyText must be set")
if not (mailTo or mailCC or mailBCC):
raise TypeError("Message must have at least one recipient")
if subject:
message.subject = subject
overrideEmail = None
#Try to get override email from settings
try:
overrideEmail = [settings.ENRICHMENT_OVERRIDE_EMAIL]
except AttributeError:
pass
#Take presidence on the parameter
if self.overrideEmail:
overrideEmail = self.overrideEmail
if not overrideEmail:
if mailTo:
message.to = list(mailTo)
if mailCC:
message.cc = list(mailCC)
if mailBCC:
message.bcc = list(mailBCC)
else:
message.to = overrideEmail
if replyTo:
message.reply_to = list(replyTo)
message.from_email = mailFrom
message.send()
def send_mail(self, sender, recipients, context=None, cc=None, bcc=None, sender_name="", attachments=None):
"""
This method sends the mail with the given parameters, replacing any variable fields with those in the context
"""
if isinstance(recipients, basestring):
recipients = [recipients]#To avoid exceptions in case there is a single recipient
if cc is None:
cc = []
if bcc is None:
bcc = []
if attachments is None:
attachments = {}
plainBody = Template(self.email_object.plainBody).render(Context(context))
htmlBody = Template(self.email_object.htmlBody).render(Context(context))
email = EmailMultiAlternatives()
email.subject = Template(self.email_object.subject).render(Context(context))
email.body = plainBody
email.attach_alternative(htmlBody, 'text/html')
email.from_email="%s <%s>" %(sender_name, sender)
email.to = recipients
email.cc = cc
email.bcc = bcc
for attachment in self.email_object.attachments.all():
email.attach("%s.%s" % (attachment.name, attachment.fileAttachment.file.name.split(".")[-1]), attachment.fileAttachment.file.read())
for attachment in attachments:
email.attach(attachment['filename'].encode('ascii', 'ignore'), attachment['data'])
return email.send()
def post(self, request):
error = None
success = None
email = request.POST.get('email', None)
if email:
email = email.strip()
try:
user = Customer.objects.get_reset_code(email)
# Sending password reset link email to user
context = {'user': user, 'SITE_NAME': settings.SITE_NAME, 'DOMAIN': settings.DOMAIN}
msg_subject = 'Password Reset'
text_content = render_to_string("accounts/email/password_reset_subject.txt",context)
to_email = '%s <%s>' % (user.get_full_name(),user)
html_content = render_to_string('accounts/email/password_reset.html', context)
msg = EmailMultiAlternatives(msg_subject, text_content)
msg.attach_alternative(html_content, "text/html")
msg.from_email = '*****@*****.**'
msg.to = [to_email]
msg.send()
success = 'Password reset intructions has been sent to your email address.'
except Exception as e:
error = e.message
else:
error = 'Please provide an email address'
return self.get(request, error=error, success=success)
def send_60_day_user_conversion_email(self, user):
# sent 60 days after signup
email = EmailMultiAlternatives()
email.subject = "Support Rhizome by Becoming a Member!"
email.to = [user.email]
email.bcc = [settings.MEMBERSHIP_GROUP_EMAIL]
email.from_email = settings.MEMBERSHIP_GROUP_EMAIL
content = {
"user":
user,
"email_body":
AutoGeneratedEmail.objects.get(
email_title='60_day_conversion').email_body
}
plaintext_template = get_template(
'accounts/emails/conversion_email_60day.txt')
plaintext_message = plaintext_template.render(Context(content))
html_template = get_template(
'accounts/emails/conversion_email_60day.html')
html_message = html_template.render(Context(content))
#send plaintext and html version
email.attach_alternative(html_message, "text/html")
email.send(fail_silently=False)
def send_15day_till_expired_email(self, membership):
email = EmailMultiAlternatives()
email.subject = "Only 15 days until your Rhizome Membership expires!"
email.to = [membership.user.email]
email.bcc = [settings.MEMBERSHIP_GROUP_EMAIL]
email.from_email = settings.MEMBERSHIP_GROUP_EMAIL
content = {
"user":
membership.user,
"email_body":
AutoGeneratedEmail.objects.get(
email_title='15_day_renewal').email_body
}
plaintext_template = get_template(
'accounts/emails/renewal_email_15day.txt')
plaintext_message = plaintext_template.render(Context(content))
html_template = get_template(
'accounts/emails/renewal_email_15day.html')
html_message = html_template.render(Context(content))
#send plaintext and html version
email.attach_alternative(html_message, "text/html")
email.send(fail_silently=False)
def async_send_mail(title, message, alert_id, sender_id):
from hub.models import Alert, Log
Log.objects.create(
type='n',
tag="async_send_mail",
message='Sending email. Title: "%s" Text: "%s" Alert: %d Sender: %d' %
(title, message, alert_id, sender_id))
alert = Alert.objects.filter(id=alert_id)
if alert:
alert = alert.first()
else:
return False
html = render_to_string('mails/alert_template.html', {'message': message})
email = EmailMultiAlternatives(title, html, to=[SERVICE_EMAIL])
email.attach_alternative(html, "text/html")
email.from_email = BOX_EMAIL
# send_mail(title, html, BOX_EMAIL, [SERVICE_EMAIL])
email.send()
alert.email_timestamp = datetime.now()
alert.email_sender_id = sender_id
alert.email_sent = True
alert.save()
Log.objects.create(type='n',
tag="async_send_mail",
message='Sent successfully')
return True
def send_mail(self: MonitoredTask, message: dict[Any, Any], email_stage_pk: Optional[int] = None):
"""Send Email for Email Stage. Retries are scheduled automatically."""
self.save_on_success = False
message_id = make_msgid(domain=DNS_NAME)
self.set_uid(slugify(message_id.replace(".", "_").replace("@", "_")))
try:
if not email_stage_pk:
stage: EmailStage = EmailStage(use_global_settings=True)
else:
stages = EmailStage.objects.filter(pk=email_stage_pk)
if not stages.exists():
self.set_status(
TaskResult(
TaskResultStatus.WARNING,
messages=["Email stage does not exist anymore. Discarding message."],
)
)
return
stage: EmailStage = stages.first()
try:
backend = stage.backend
except ValueError as exc:
# pyright: reportGeneralTypeIssues=false
LOGGER.warning(exc)
self.set_status(TaskResult(TaskResultStatus.ERROR).with_error(exc))
return
backend.open()
# Since django's EmailMessage objects are not JSON serialisable,
# we need to rebuild them from a dict
message_object = EmailMultiAlternatives()
for key, value in message.items():
setattr(message_object, key, value)
if not stage.use_global_settings:
message_object.from_email = stage.from_address
# Because we use the Message-ID as UID for the task, manually assign it
message_object.extra_headers["Message-ID"] = message_id
LOGGER.debug("Sending mail", to=message_object.to)
backend.send_messages([message_object])
Event.new(
EventAction.EMAIL_SENT,
message=(f"Email to {', '.join(message_object.to)} sent"),
subject=message_object.subject,
body=get_email_body(message_object),
from_email=message_object.from_email,
to_email=message_object.to,
).save()
self.set_status(
TaskResult(
TaskResultStatus.SUCCESSFUL,
messages=["Successfully sent Mail."],
)
)
except (SMTPException, ConnectionError, OSError) as exc:
LOGGER.debug("Error sending email, retrying...", exc=exc)
self.set_status(TaskResult(TaskResultStatus.ERROR).with_error(exc))
raise exc
def send_installation_email(event_name, postinstall_email, attendee):
email = EmailMultiAlternatives()
first_name = attendee.first_name
last_name = attendee.last_name
email.subject = get_installation_subject(first_name, last_name, event_name)
email.from_email = postinstall_email.contact_email
email.body = ''
email.attach_alternative(postinstall_email.message, "text/html")
email.to = [attendee.email]
email.send(fail_silently=False)
def _convert_to_django_msg(msg):
body, alternatives = _get_content(msg)
if alternatives:
email = EmailMultiAlternatives(body=body, alternatives=alternatives)
else:
email = EmailMessage(body=body)
email.subject = _parse_header(msg['Subject'])
email.to = _parse_header(msg['To'])
email.cc = _parse_header(msg.get('Cc', None))
email.bcc = _parse_header(msg.get('Bcc', None))
email.from_email = _parse_header(msg['From'])
return email
def handle_signoff_emails(instance, created, **kwargs):
if not created:
return
message = EmailMultiAlternatives()
# Collect recipients based on site settings
if hasattr(settings, 'SIGNOFF_EMAIL_USER') and\
settings.SIGNOFF_EMAIL_USER:
message.to = [
instance.user.email,
]
if hasattr(settings, 'SIGNOFF_EMAIL_RECEIPT') and\
settings.SIGNOFF_EMAIL_RECEIPT:
if message.to:
message.bcc = settings.SIGNOFF_EMAIL_RECEIPT
else:
message.to = settings.SIGNOFF_EMAIL_RECEIPT
# If neither key is true, then we have no recipients, and therefore no mail
# to send
if not message.to:
return
if hasattr(settings, 'SIGNOFF_EMAIL_FROM') and\
settings.SIGNOFF_EMAIL_FROM:
message.from_email = settings.SIGNOFF_EMAIL_FROM
if hasattr(settings, 'SIGNOFF_EMAIL_REPLY_TO') and\
settings.SIGNOFF_EMAIL_REPLY_TO:
message.reply_to = (settings.SIGNOFF_EMAIL_REPLY_TO, )
# Build message
template_context = {
'document': instance.document,
'user': instance.user,
'instance': instance,
}
message.subject = render_to_string(
'signoff/email_subject.txt',
context=template_context,
).strip()
html_body = render_to_string(
'signoff/email_body.html',
context=template_context,
).strip()
message.body = html_body
message.attach_alternative(html_body, 'text/html')
message.send()
def _convert_to_django_msg(msg):
body, alternatives = _get_content(msg)
if alternatives:
email = EmailMultiAlternatives(body=body, alternatives=alternatives)
else:
email = EmailMessage(body=body)
email.subject = _parse_header(msg["Subject"])
email.to = _parse_header(msg["To"])
email.cc = _parse_header(msg.get("Cc", None))
email.bcc = _parse_header(msg.get("Bcc", None))
email.from_email = _parse_header(msg["From"])
return email
def send_order_confirmation(self, request, order_email):
"""Sends email to user confirming order and contents"""
user = self.profile.user
context = Context({
'user': user,
'cart': self.cart,
'MEDIA_URL': settings.MEDIA_URL,
'SITE_URL': settings.SITE_URL
})
subject = 'Thanks for the biz! Here\'s your order confirmation.'
from_email = 'Sean Dominguez <*****@*****.**>'
# If at order screen, user provided an email address
if order_email != '':
to = order_email
else:
to = self.profile.user.email
text_content = render_to_string('orders/email/order_confirmation.txt',
context)
html_content = render_to_string('orders/email/order_confirmation.html',
context)
msg = EmailMultiAlternatives(subject, text_content)
msg.attach_alternative(html_content, "text/html")
msg.to = [to]
msg.from_email = from_email
# Send a copy to me after finished as well
msg_copy = EmailMultiAlternatives("Copy of order confirmation",
text_content)
msg_copy.attach_alternative(html_content, "text/html")
msg_copy.to = ['*****@*****.**']
msg_copy.from_email = from_email
msg.send()
msg_copy.send()
def installation(request, event_slug):
installation_form = InstallationForm(request.POST or None, prefix='installation')
hardware_form = HardwareForm(request.POST or None, prefix='hardware')
forms = [installation_form, hardware_form]
errors = []
if request.POST:
if hardware_form.is_valid() and installation_form.is_valid():
try:
hardware = hardware_form.save()
install = installation_form.save()
install.hardware = hardware
event = Event.objects.filter(slug__iexact=event_slug).first()
if not event:
return handler404(request)
install.event = event
install.installer = EventUser.objects.filter(user=request.user).filter(event=event).first()
install.save()
# Send post-install email if its defined
postinstall_email = InstallationMessage.objects.filter(event=event).first()
if postinstall_email:
attendee = install.attendee
email = EmailMultiAlternatives()
subject = _(
u"%(first_name)s %(last_name)s, thank you for participating in FLISoL %(event_name)s") % {
'event_name': event.name, 'first_name': attendee.first_name,
'last_name': attendee.last_name}
email.from_email = postinstall_email.contact_email
email.subject = unicode(subject)
email.body = ''
email.attach_alternative(postinstall_email.message, "text/html")
email.to = [attendee.email]
try:
email.send(fail_silently=False)
except Exception:
# Don't raise email exception to form exception
pass
messages.success(request, _("The installation has been registered successfully. Happy Hacking!"))
return HttpResponseRedirect('/event/' + event_slug)
except Exception as e:
logger.error(e)
if hardware is not None:
Hardware.delete(hardware)
if install is not None:
Installation.delete(install)
messages.error(request, _("The installation couldn't be registered (check form errors)"))
errors = get_forms_errors(forms)
return render(request,
'installation/installation-form.html',
update_event_info(event_slug, request, {'forms': forms, 'errors': errors, 'multipart': False}))
def form_valid(self, form):
# Create a user, but remember to set inactive!
user = User()
user.username = form.cleaned_data['email']
user.email = form.cleaned_data['email']
user.is_active = False
try:
user.save()
except IntegrityError:
form.add_error('email',
gettext('Shop with this email already exists.'))
return super(ShopRegisterView, self).form_invalid(form)
self.object = form.save(commit=False)
self.object.postcode = Postcode.objects.get(
postcode=form.cleaned_data['postcode_special'])
self.object.user = user
self.object.save()
current_site = get_current_site(self.request)
context = {
'shopname': self.object.name,
'user': user,
'domain': current_site.domain,
'uid': urlsafe_base64_encode(force_bytes(user.pk)),
'token': account_activation_token.make_token(user),
}
html_message = render_to_string('emails/account_activation.html',
context)
txt_message = render_to_string('emails/account_activation.txt',
context)
email = EmailMultiAlternatives(gettext('FOODBEE - Confirm email'),
txt_message)
email.from_email = settings.DEFAULT_FROM_EMAIL
email.to = [self.object.email]
email.attach_alternative(html_message, "text/html")
email.content_subtype = 'html'
email.mixed_subtype = 'related'
with open('base/static/base/img/fb_logo.png', mode='rb') as f:
image = MIMEImage(f.read())
image.add_header('Content-ID', "<Foodbee_logo_long.png>")
email.attach(image)
email.send()
return super().form_valid(form)
def installation(request, event_slug):
installation_form = InstallationForm(event_slug, request.POST or None, prefix='installation')
hardware_form = HardwareForm(request.POST or None, prefix='hardware')
forms = [installation_form, hardware_form]
errors = []
if request.POST:
if hardware_form.is_valid() and installation_form.is_valid():
try:
hardware = hardware_form.save()
install = None
install = installation_form.save()
install.hardware = hardware
event = Event.objects.filter(slug__iexact=event_slug).first()
if not event:
return handler404(request)
install.event = event
install.installer = EventUser.objects.filter(user=request.user).filter(event=event).first()
install.save()
#Send post-install email if its defined
postinstallemail = InstallationMessage.objects.filter(event=event).first()
if postinstallemail:
attendee = install.attendee
email = EmailMultiAlternatives()
subject = _(u"%(first_name)s %(last_name)s, thank you for participating in FLISoL %(event_name)s") % {
'event_name': event.name, 'first_name': attendee.user.first_name, 'last_name': attendee.user.last_name}
email.from_email = postinstallemail.contact_email
email.subject = unicode(subject)
email.body = ''
email.attach_alternative(postinstallemail.message, "text/html")
email.to = [attendee.user.email]
try:
email.send(fail_silently=False)
except Exception:
#Don't raise email exception to form exception
pass
messages.success(request, _("The installation has been registered successfully. Happy Hacking!"))
return HttpResponseRedirect('/event/' + event_slug)
except Exception:
if hardware is not None:
Hardware.delete(hardware)
if install is not None:
Installation.delete(install)
messages.error(request, _("The installation couldn't be registered (check form errors)"))
errors = get_forms_errors(forms)
return render(request,
'installation/installation-form.html',
update_event_info(event_slug, request, {'forms': forms, 'errors': errors, 'multipart': False}))
def _convert_to_django_msg(msg):
from django.core.mail import EmailMessage, EmailMultiAlternatives
body, alternatives = _get_content(msg)
if alternatives:
email = EmailMultiAlternatives(body=body,
alternatives=alternatives)
else:
email = EmailMessage(body=body)
email.subject = _parse_header(msg['Subject'])
email.to = _parse_header(msg['To'])
email.cc = _parse_header(msg.get('Cc', None))
email.bcc = _parse_header(msg.get('Bcc', None))
email.from_email = _parse_header(msg['From'])
return email
def check_birthday(info_mail, body_text, subject):
"""TODO"""
today = datetime.date.today()
future = today + datetime.timedelta(days=2)
members = Member.objects.filter(
birthday__day=future.day, birthday__month=future.month)
if members.count() == 0:
return 'No upcomming birthdays!'
message = EmailMessage(subject=subject)
template = Template(body_text)
context = Context({'member_list': members})
message.body = template.render(context)
message.to = [info_mail]
message.from_email = 'JUSO Aargau <*****@*****.**>'
message.send()
return '{x} birthdays sent'.format(x=members.count())
def message(self):
m = EmailMultiAlternatives(self.subject, self.body)
m.to = self.to
m.cc = self.cc
m.bcc = self.bcc
m.from_email = self.from_email
m.alternatives = \
[(att.content, att.mimetype) for att in self.alternatives()]
for attachment in self.attachments():
m.attach(attachment.filename, attachment.content.read(),
attachment.mimetype)
m.extra_headers = self.extra_headers
return m
def add_staff(request):
response = {}
try:
event_id = request.POST["event_id"]
staff_type = request.POST['staff_type']
username = request.POST['username']
name = request.POST['name']
url = request.POST['url']
imgurl = request.POST['imgurl']
event = Event.objects.get(id=event_id)
try:
user = User.objects.get(username=username)
except User.DoesNotExist:
user = None
staff = Staff()
staff.staff = user
staff.name = name
staff.url = url
staff.event = event
staff.type = staff_type
staff.imgurl = imgurl
staff.save()
to = [event.creator.username]
for attendee in event.attendee_set.all():
if not to.__contains__(attendee.attendee.username):
to.append(attendee.attendee.username)
msg = EmailMultiAlternatives()
msg.from_email = "*****@*****.**"
msg.to = to
msg.subject = "New Attendee!"
body = "A new " + ("Organizer" if staff_type == "O" else ("Speaker" if staff_type == "S" else "Mentor")) + " has been added to the event <a href='http://events-finder.appspot.com/event/" + event_id + "'>" + event.name + "</a>!"
msg.body = body
msg.attach_alternative(body, 'text/html')
send_async_mail(msg)
response['staff_id'] = staff.id
except Exception, err:
response['error'] = err.__str__()
def _view_subscriber_verification_context(request, form_class):
"""
A simple view that shows a form for subscription for the newsletter.
"""
context = {}
if request.POST:
context['form'] = form_class(request.POST)
if context['form'].is_valid():
subscription = SubscriberVerification()
contact = context['form'].save()
subscription.contact = context['form'].instance
subscription.save()
link_id = str(subscription.link_id)
mail_context = Context({
'base_url': "%s://%s" % ("https" if request.is_secure() else "http", request.get_host()),
'link_id': link_id,
})
content_html = render_to_string('newsletter/newsletter_mail_verification.html', mail_context)
content_text = html2text(content_html)
message = EmailMultiAlternatives()
message.from_email = smart_str(DEFAULT_HEADER_REPLY)
message.extra_headers = {'Reply-to': smart_str(DEFAULT_HEADER_REPLY)}
message.to = [smart_str(context['form'].instance.email)]
message.subject = render_to_string('newsletter/newsletter_mail_verification_subject.html', context)
message.body = smart_str(content_text)
message.attach_alternative(smart_str(content_html), "text/html")
try:
message.send()
except Exception, e:
print e
context['send'] = True
def send_30day_till_expired_email(self, membership):
email = EmailMultiAlternatives()
email.subject = "30 days until your Rhizome Membership expires!"
email.to = [membership.user.email]
email.bcc = [settings.MEMBERSHIP_GROUP_EMAIL]
email.from_email = settings.MEMBERSHIP_GROUP_EMAIL
content = {
"user": membership.user,
"email_body": AutoGeneratedEmail.objects.get(email_title = '30_day_renewal').email_body
}
plaintext_template = get_template('accounts/emails/renewal_email_30day.txt')
plaintext_message = plaintext_template.render(Context(content))
html_template = get_template('accounts/emails/renewal_email_30day.html')
html_message = html_template.render(Context(content))
#send plaintext and html version
email.attach_alternative(html_message, "text/html")
email.send(fail_silently=False)
def send_mail(self,
sender,
recipients,
context=None,
cc=None,
bcc=None,
sender_name="",
attachments=None):
"""
This method sends the mail with the given parameters, replacing any variable fields with those in the context
"""
if cc is None:
cc = []
if bcc is None:
bcc = []
if attachments is None:
attachments = {}
plainBody = Template(self.email_object.plainBody).render(
Context(context))
htmlBody = Template(self.email_object.htmlBody).render(
Context(context))
email = EmailMultiAlternatives()
email.subject = Template(self.email_object.subject).render(
Context(context))
email.body = plainBody
email.attach_alternative(htmlBody, 'text/html')
email.from_email = "%s <%s>" % (sender_name, sender)
email.to = recipients
email.cc = cc
email.bcc = bcc
for attachment in self.email_object.attachments.all():
email.attach(
"%s.%s" % (attachment.name,
attachment.fileAttachment.file.name.split(".")[-1]),
attachment.fileAttachment.file.read())
for attachment in attachments:
email.attach(attachment['filename'].encode('ascii', 'ignore'),
attachment['data'])
email.tags = map(unicode.strip, self.email_object.tags.split(','))
email.track_clicks = True
return email.send()
def send_60_day_user_conversion_email(self, user):
# sent 60 days after signup
email = EmailMultiAlternatives()
email.subject = "Support Rhizome by Becoming a Member!"
email.to = [user.email]
email.bcc = [settings.MEMBERSHIP_GROUP_EMAIL]
email.from_email = settings.MEMBERSHIP_GROUP_EMAIL
content = {
"user": user,
"email_body": AutoGeneratedEmail.objects.get(email_title = '60_day_conversion').email_body
}
plaintext_template = get_template('accounts/emails/conversion_email_60day.txt')
plaintext_message = plaintext_template.render(Context(content))
html_template = get_template('accounts/emails/conversion_email_60day.html')
html_message = html_template.render(Context(content))
#send plaintext and html version
email.attach_alternative(html_message, "text/html")
email.send(fail_silently=False)
def default_delivery_handler(sender, **kwargs):
message = kwargs.get('message', None)
if message and 'email' in message.message_format:
msg = EmailMultiAlternatives()
msg.subject = message.subject
msg.body = message.body
if message.sender():
msg.from_email = message.sender().contact_info
msg.to = [r.contact_info for r in message.recipients() if r.role == 'to']
# FIXME: Django doesn't yet support the CC field, so just add CC'ed
# recipients in the To: field for now.
msg.to += [r.contact_info for r in message.recipients() if r.role == 'cc']
msg.bcc = [r.contact_info for r in message.recipients() if r.role == 'bcc']
for attachment in getattr(message, 'attachments', []):
if isinstance(attachment, (list, tuple)):
if len(attachment) >= 1 and attachment[0] is None:
msg.attach_alternative(*attachment[1:])
else:
msg.attach(*attachment)
else:
msg.attach(attachment)
return msg.send()
def attend_event(request):
response = {}
try:
event_id = request.POST["event_id"]
attendee_type = request.POST['attendee_type']
event = Event.objects.get(id=event_id)
if attendee_type != "" and not Attendee.objects.filter(attendee=request.user, event=event).exists():
attendee = Attendee()
attendee.attendee = request.user
attendee.event = event
attendee.type = attendee_type
attendee.save()
to = [event.creator.username]
for attendee in event.attendee_set.all():
if not to.__contains__(attendee.attendee.username):
to.append(attendee.attendee.username)
msg = EmailMultiAlternatives()
msg.from_email = "*****@*****.**"
msg.to = to
msg.subject = "New Attendee!"
body = "<a href='http://events-finder.appspot.com/accounts/view/" + request.user.username + "'>" + request.user.first_name + " " + request.user.last_name + "</a> is now " + ('attending' if attendee_type == 'A' else 'tracking') + " the event <a href='http://events-finder.appspot.com/event/" + event_id + "'>" + event.name + "</a>!"
msg.body = body
msg.attach_alternative(body, 'text/html')
send_async_mail(msg)
else:
attendee_instance = Attendee.objects.get(attendee=request.user, event=event)
attendee_instance.delete()
except Exception, err:
response['error'] = err.__str__()
def attend_event(request):
response = {}
try:
event_id = request.POST["event_id"]
attendee_type = request.POST['attendee_type']
event = Event.objects.get(id=event_id)
if attendee_type != "" and not Attendee.objects.filter(attendee=request.user, event=event).exists():
attendee = Attendee()
attendee.attendee = request.user
attendee.event = event
attendee.type = attendee_type
attendee.save()
to = [event.creator.username]
for attendee in event.attendee_set.all():
if not to.__contains__(attendee.attendee.username):
to.append(attendee.attendee.username)
msg = EmailMultiAlternatives()
msg.from_email = "*****@*****.**"
msg.to = to
msg.subject = "New Attendee!"
body = "<a href='http://events-finder.appspot.com/accounts/view/" + request.user.username + "'>" + request.user.first_name + " " + request.user.last_name + "</a> is now " + ('attending' if attendee_type == 'A' else 'tracking') + " the event <a href='http://events-finder.appspot.com/event/" + event_id + "'>" + event.name + "</a>!"
msg.body = body
msg.attach_alternative(body, 'text/html')
send_async_mail(msg)
else:
attendee_instance = Attendee.objects.get(attendee=request.user, event=event)
attendee_instance.delete()
except Exception, err:
response['error'] = err.__str__()
def post(self, request):
data = request.POST
if data['content'] == '':
return HttpResponse(status=404)
user = request.user
email = EmailMultiAlternatives()
email.from_email = '*****@*****.**' # Change? from user.email
email.to = [data['send_to']]
email.body = data['content']
if data['subject'] == '':
email.subject = f'No subject - ({user.username} #{user.email})'
else:
email.subject = data['subject'] + f' - ({user.username} #{user.email})'
if request.FILES:
file = request.FILES['file']
email.attach(file.name, file.read(), file.content_type)
email.send(False)
return HttpResponse(status=204)
def add_bounce_sender(sender, message: EmailMultiAlternatives, order,
**kwargs):
if not settings.CONFIG_FILE.has_section('bounces') or not order:
return message
if order.event.settings.smtp_use_custom:
return message
from_domain = settings.CONFIG_FILE.get('bounces',
'from_domain',
fallback='')
if from_domain and '@' + from_domain not in message.from_email:
return message
alias = generate_new_alias(order)
from_email = message.from_email
if 'Reply-To' not in message.extra_headers:
message.extra_headers['Reply-To'] = from_email
message.from_email = alias
message.extra_headers.update({'From': from_email, 'Sender': alias})
return message
def send_mail(content, recipients, attachments):
"""Docstring"""
mails = []
for recipient in serializers.deserialize("json", recipients):
mail_ = EmailMessage(content['subject'])
message = content['message'].format(member=recipient.object)
mail_.body = message
message = render_html(message, content['etype'], content['img_url'],
content['sender'], content['template'])
mail_.attach_alternative(message, 'text/html')
mail_.from_email = '{name} <{email}>'.format(
email=content['sender'], name=content['name'])
mail_.to = [recipient.object.email]
for att in attachments:
mail_.attach(att['name'], open(att['path'], 'rb').read())
mails.append(mail_)
connection = mail.get_connection()
for mail_ in mails:
try:
connection.send_messages([mail_])
except:
pass
return "Success!"
def enviar_cotizacion(self, cotizacion, user, email_adicional=None):
version_cotizacion = cotizacion.version
from_ventas_email = EmailConfiguration.objects.first(
).email_ventas_from
if not from_ventas_email:
from_ventas_email = settings.DEFAULT_FROM_EMAIL
enviar_como = user.user_extendido.email_envio_como
if enviar_como:
enviar_como = '%s - %s' % (user.user_extendido.email_envio_como,
user.get_full_name())
else:
enviar_como = 'ODECOPACK - %s' % (user.get_full_name())
if user.email:
email_split = user.email.split('@')
if email_split[-1] in list(
DominiosEmail.objects.values_list('dominio',
flat=True).all()):
from_email = "%s <%s>" % (enviar_como, user.email)
else:
from_email = "%s <%s>" % (enviar_como, from_ventas_email)
else:
from_email = "%s <%s>" % (enviar_como, from_ventas_email)
if email_adicional:
to = [cotizacion.email, email_adicional]
else:
to = [cotizacion.email]
subject = "%s - %s" % ('Cotizacion', cotizacion.nro_cotizacion)
if version_cotizacion > 1:
subject = "%s, version %s" % (subject, cotizacion.version)
ctx = {
'object': cotizacion,
}
try:
colaborador = Colaborador.objects.get(usuario__user=user)
except Colaborador.DoesNotExist:
colaborador = None
if not cotizacion.cliente_nuevo:
colaboradores = SucursalBiable.objects.values(
'vendedor_real__colaborador_id').filter(
cliente_id=cotizacion.cliente_biable_id,
vendedor_real__isnull=False).distinct()
if colaboradores.exists():
if colaboradores.count() == 1:
colaborador = Colaborador.objects.get(
pk=colaboradores.first()
['vendedor_real__colaborador_id'])
cotizacion.usuario = colaborador.usuario.user
cotizacion.save()
else:
colaborador = Colaborador.objects.get(usuario__user=user)
if colaborador:
if colaborador.foto_perfil:
url_avatar = colaborador.foto_perfil.url
ctx['avatar'] = url_avatar
nombre_archivo_cotizacion = "Cotizacion Odecopack - CB %s.pdf" % (
cotizacion.id)
if version_cotizacion > 1:
ctx['version'] = cotizacion.version
nombre_archivo_cotizacion = "Cotizacion Odecopack - CB %s ver %s.pdf" % (
cotizacion.id, cotizacion.version)
text_content = render_to_string('cotizaciones/emails/cotizacion.html',
ctx)
html_content = get_template(
'cotizaciones/emails/cotizacion.html').render(Context(ctx))
output = BytesIO()
HTML(string=html_content).write_pdf(target=output)
msg = EmailMultiAlternatives(subject,
text_content,
from_email,
to=to,
reply_to=[user.email])
msg.attach_alternative(html_content, "text/html")
msg.attach(nombre_archivo_cotizacion, output.getvalue(),
'application/pdf')
if cotizacion.mis_imagenes:
for imagen in cotizacion.mis_imagenes.all():
try:
docfile = imagen.imagen.read()
if docfile:
nombre_archivo = imagen.imagen.name.split("/")[-1]
msg.attach(nombre_archivo, docfile)
docfile.close()
else:
pass
except:
pass
msg.send()
# Envio al asesor
msg.from_email = "Confirmación <*****@*****.**>"
msg.to = [user.email]
msg.reply_to = None
msg.send()
output.close()
cotizacion.save()
if not cotizacion.cliente_nuevo:
seguimiento = SeguimientoComercialCliente()
seguimiento.cotizacion = cotizacion
seguimiento.creado_por = self.request.user
seguimiento.cliente = cotizacion.cliente_biable
observacion_adicional = "<p> Valor Cotización: " + str(
cotizacion.total) + "</p>"
if cotizacion.descuento:
observacion_adicional += "<p> Descuento Cotización: " + str(
cotizacion.descuento) + "</p>"
seguimiento.observacion_adicional = observacion_adicional
if version_cotizacion > 1:
seguimiento.tipo_accion = "Envío version " + str(
version_cotizacion)
else:
seguimiento.tipo_accion = "Nueva"
seguimiento.save()
def form_valid(self, form):
self.object = form.save()
# Fetch all products
basket = self.request.session.get('basket', [])
products_in_basket = [item.get('product') for item in basket]
products = Product.objects.filter(pk__in=products_in_basket,
active=True,
shop__active=True).order_by('shop')
products_dict = {product.pk: product for product in products}
# Total cost & valid items list per shop
shop_items_and_cost = dict.fromkeys(
{product.shop
for product in products})
for key in shop_items_and_cost:
shop_items_and_cost[key] = {
'total_cost': Decimal(0.00),
'order_items': [],
'item_count': 0
}
# Create orderItems
for item in basket:
product = products_dict[item.get('product')]
count = item.get('count')
# If product is not found, skip product
if product is None:
continue
# If count is 0 or below, skip item
if count < 1:
continue
order_item = OrderItem()
order_item.product = product
order_item.order = self.object
order_item.count = count
# Save the offer/on sale price if any, else use normal price
order_item.price = product.offer_price if product.offer_price else product.price
order_item.save()
shop_items_and_cost[product.shop]['item_count'] += count
shop_items_and_cost[product.shop]['total_cost'] += Decimal(
order_item.subtotal())
shop_items_and_cost[product.shop]['order_items'].append(order_item)
context = {
'order': self.object,
'shop_items_and_cost': shop_items_and_cost
}
html_message = render_to_string('emails/order_confirmation.html',
context)
txt_message = render_to_string('emails/order_confirmation.txt',
context)
subject = gettext('Order confirmation')
self.object.status = Order.ORDERED
email = EmailMultiAlternatives(subject, txt_message)
email.from_email = settings.DEFAULT_FROM_EMAIL
email.to = [self.object.email]
email.attach_alternative(html_message, "text/html")
email.content_subtype = 'html'
email.mixed_subtype = 'related'
with open('base/static/base/img/fb_logo.png', mode='rb') as f:
image = MIMEImage(f.read())
image.add_header('Content-ID', "<Foodbee_logo_long.png>")
email.attach(image)
email.send()
# Clear session
self.request.session.flush()
return HttpResponseRedirect(self.get_success_url())
def setUp(self):
organization, created = Organization.objects.get_or_create(name='Example Corp')
self.mailbox = Mailbox.objects.create(
name='test_mailbox',
uri='maildir://' + MAILDIR_PATH,
from_email='*****@*****.**'
)
# clear any pre-existing messages in the local mailbox
self.maildir.clear()
self.team, created = Team.objects.get_or_create(
name='Example Department',
slug='example_dept',
mailbox=self.mailbox
)
self.ticket, created = Ticket.objects.get_or_create(
title='Testing 123 Ticket',
organization=organization,
priority=4
)
self.ticket.teams.add(self.team)
self.sender_email = EmailAddress.objects.create(email_address=self._sender_email)
self.sender = Person.objects.create(
first_name='sender_first_name',
last_name='sender_last_name'
)
self.sender.email_addresses.add(self.sender_email)
self.recipient_email = EmailAddress.objects.create(email_address=self._recipient_email)
self.recipient = Person.objects.create(
first_name='recipient_first_name',
last_name='recipient_last_name',
)
self.recipient.email_addresses.add(self.recipient_email)
cc_people, cc_emails = list(), list()
for addr in self._cc_emails:
email = EmailAddress.objects.create(email_address=addr)
person = Person.objects.create(
first_name='{}_first_name'.format(addr.split('@')[0]),
last_name='{}_last_name'.format(addr.split('@')[0])
)
person.email_addresses.add(email)
cc_emails.append(email)
cc_people.append(person)
self.cc_emails = cc_emails
self.cc_people = cc_people
email_message = EmailMultiAlternatives()
email_message.body = 'Test message testing 123'
email_message.from_email = self._sender_email
email_message.to = self._recipient_email,
email_message.cc = self._cc_emails
email_message.subject = 'tests message subject'
email_message.extra_headers['Message-Id'] = 'unique_id_goes_here'
self.email_message_no_hashid_plain = copy.deepcopy(email_message)
email_message.attach_alternative(
'<html><body><p>Test message testing 123</p></body></html>',
'text/html'
)
self.email_message_no_hashid = email_message
def prepare_message(self, contact):
from emencia.utils.tokens import tokenize
from emencia.utils.newsletter import fix_tinymce_links
uidb36, token = tokenize(contact)
base_url = self.base_url
context = Context({
'contact': contact,
'base_url': base_url,
'newsletter': self,
'tracking_image_format': TRACKING_IMAGE_FORMAT,
'uidb36': uidb36,
'token': token,
'UNIQUE_KEY': ''.join(sample(UNIQUE_KEY_CHAR_SET, UNIQUE_KEY_LENGTH))
})
message = EmailMultiAlternatives()
message.from_email = smart_str(self.header_sender)
message.extra_headers = {'Reply-to': smart_str(self.header_reply)}
message.to = [contact.mail_format()]
# Render only the message provided by the user with the WYSIWYG editor
message_template = Template(fix_tinymce_links(self.content))
message_content = message_template.render(context)
context.update({'message': message_content})
# link_site_exist = False
link_site = render_to_string('newsletter/newsletter_link_site.html', context)
context.update({'link_site': link_site})
if INCLUDE_UNSUBSCRIPTION:
unsubscription = render_to_string('newsletter/newsletter_link_unsubscribe.html', context)
context.update({'unsubscription': unsubscription})
if TRACKING_IMAGE:
image_tracking = render_to_string('newsletter/newsletter_image_tracking.html', context)
context.update({'image_tracking': image_tracking})
content_template = get_template('mailtemplates/{0}/{1}'.format(self.template, 'index.html'))
content = content_template.render(context)
if TRACKING_LINKS:
from emencia.utils.newsletter import track_links
content = track_links(content, context)
content = smart_unicode(content)
p = Premailer(content, base_url=base_url, preserve_internal_links=True)
content = p.transform()
# newsletter_template = Template(self.content)
message.body = html2text(content)
message.attach_alternative(smart_str(content), "text/html")
title_template = Template(self.title)
title = title_template.render(context)
message.subject = title
for attachment in self.attachments:
message.attach(attachment)
return message
def prepare_message(self, contact):
from emencia.utils.tokens import tokenize
from emencia.utils.newsletter import fix_tinymce_links
uidb36, token = tokenize(contact)
base_url = self.base_url
context = Context({
'contact':
contact,
'base_url':
base_url,
'newsletter':
self,
'tracking_image_format':
TRACKING_IMAGE_FORMAT,
'uidb36':
uidb36,
'token':
token,
'UNIQUE_KEY':
''.join(sample(UNIQUE_KEY_CHAR_SET, UNIQUE_KEY_LENGTH))
})
message = EmailMultiAlternatives()
message.from_email = smart_str(self.header_sender)
message.extra_headers = {'Reply-to': smart_str(self.header_reply)}
message.to = [contact.mail_format()]
# Render only the message provided by the user with the WYSIWYG editor
message_template = Template(fix_tinymce_links(self.content))
message_content = message_template.render(context)
context.update({'message': message_content})
# link_site_exist = False
link_site = render_to_string('newsletter/newsletter_link_site.html',
context)
context.update({'link_site': link_site})
if INCLUDE_UNSUBSCRIPTION:
unsubscription = render_to_string(
'newsletter/newsletter_link_unsubscribe.html', context)
context.update({'unsubscription': unsubscription})
if TRACKING_IMAGE:
image_tracking = render_to_string(
'newsletter/newsletter_image_tracking.html', context)
context.update({'image_tracking': image_tracking})
content_template = get_template('mailtemplates/{0}/{1}'.format(
self.template, 'index.html'))
content = content_template.render(context)
if TRACKING_LINKS:
from emencia.utils.newsletter import track_links
content = track_links(content, context)
content = smart_unicode(content)
p = Premailer(content, base_url=base_url, preserve_internal_links=True)
content = p.transform()
# newsletter_template = Template(self.content)
message.body = html2text(content)
message.attach_alternative(smart_str(content), "text/html")
title_template = Template(self.title)
title = title_template.render(context)
message.subject = title
for attachment in self.attachments:
message.attach(attachment)
return message
def email(subject,
template_name,
merge_data={},
merge_global_data={},
recipients=[],
preheader=None,
bcc=None,
reply_to=None,
send=True):
from django.conf import settings
if not (subject and template_name and recipients):
raise NameError()
if not isinstance(recipients, list):
raise TypeError("recipients must be a list")
# bcc is set to False by default.
# make sure bcc is in a list form when sent over
if bcc not in [False, None] and not isinstance(bcc, list):
raise TypeError("recipients must be a list")
merge_global_data['subject'] = subject
merge_global_data['current_year'] = timezone.now().year
merge_global_data['company_name'] = settings.SITE_NAME
merge_global_data['site_url'] = settings.SITE_URL
if preheader:
merge_global_data['preheader'] = preheader
msg = EmailMultiAlternatives()
msg.body = render_to_string(f"{template_name}.html")
msg.content_subtype = "html"
msg.from_email = f"CoderDojoChi<{settings.DEFAULT_FROM_EMAIL}>"
msg.merge_data = merge_data
msg.merge_global_data = merge_global_data
msg.subject = subject
msg.to = recipients
if reply_to:
msg.reply_to = reply_to
if send:
try:
msg.send()
except Exception as e:
logger.error(e)
logger.error(msg)
raise e
for recipient in msg.anymail_status.recipients.keys():
send_attempt = msg.anymail_status.recipients[recipient]
if send_attempt.status not in ['queued', 'sent']:
logger.error(f"user: {recipient}, {timezone.now()}")
from coderdojochi.models import CDCUser
user = CDCUser.objects.get(email=recipient)
user.is_active = False
user.admin_notes = f"User '{send_attempt.reject_reason}' when checked on {timezone.now()}"
user.save()
return msg
