def serve(self, request, *args, **kwargs):
if request.is_ajax() and request.method == "POST":
form = GoogleAdGrantApplicationForm(request.POST)
if form.is_valid():
form.save()
if self.to_address:
subject = "{} form submission".format(self.title)
content = '\n'.join([
x[1].label + ': ' + str(form.data.get(x[0]))
for x in form.fields.items()
])
send_mail(
subject,
content,
[self.to_address],
)
return render(
request,
'torchbox/includes/ad_grant_application_landing.html', {
'self': self,
'form': form
})
else:
return render(
request,
'torchbox/includes/ad_grant_application_form.html', {
'self': self,
'form': form
})
else:
return super(GoogleAdGrantsPage, self).serve(request)
def test_send_html_email(self):
"""Test that the kwarg 'html_message' works as expected on send_mail by creating 'alternatives' on the EmailMessage object"""
send_mail("Test HTML subject",
"TEXT content", ["*****@*****.**"],
html_message="<h2>Test HTML content</h2>")
send_mail("Test TEXT subject", "TEXT content",
["*****@*****.**"])
# Check that the emails were sent
self.assertEqual(len(mail.outbox), 2)
# check that the first email is the HTML email
email_message = mail.outbox[0]
self.assertEqual(email_message.subject, "Test HTML subject")
self.assertEqual(email_message.alternatives,
[('<h2>Test HTML content</h2>', 'text/html')])
self.assertEqual(
email_message.body, "TEXT content"
) # note: plain text will always be added to body, even with alternatives
self.assertEqual(email_message.to, ["*****@*****.**"])
# confirm that without html_message kwarg we do not get 'alternatives'
email_message = mail.outbox[1]
self.assertEqual(email_message.subject, "Test TEXT subject")
self.assertEqual(email_message.alternatives, [])
self.assertEqual(email_message.body, "TEXT content")
self.assertEqual(email_message.to, ["*****@*****.**"])
def process_form_submission(self, form):
submission = super().process_form_submission(form)
if self.send_confirmation_mail:
# find mail field
mail_field = self.form_fields.get(
label=self.confirmation_mail_field)
clean_mail_field = mail_field.clean_name
address = form[clean_mail_field].value()
html_content = render_to_string(
"core/mails/form_confirmation.html",
{
"confirmation_mail_text": self.confirmation_mail_text,
"title": self.title,
},
)
text_content = html2text.html2text(self.confirmation_mail_text)
send_mail(
self.confirmation_mail_subject,
text_content,
[address],
self.from_address,
html_message=html_content,
)
return submission
def send_mail(self, form):
addresses = [x.strip() for x in self.to_address.split(",")]
send_mail(
self.subject,
self.render_email(form),
addresses,
self.from_address,
)
def send_user_mail(self, form):
"""Sends the email notification to the user who submitted the form.
Depends on there being a form field labelled 'Email'"""
address = form.cleaned_data.get("email")
if address:
send_mail(
self.subject, self.render_email(form), [address], self.from_address,
)
def test_send_email(self):
send_mail("Test subject", "Test content", ["*****@*****.**"], "*****@*****.**")
# Check that the email was sent
self.assertEqual(len(mail.outbox), 1)
self.assertEqual(mail.outbox[0].subject, "Test subject")
self.assertEqual(mail.outbox[0].body, "Test content")
self.assertEqual(mail.outbox[0].to, ["*****@*****.**"])
self.assertEqual(mail.outbox[0].from_email, "*****@*****.**")
def test_send_fallback_to_default_from_email_setting(self):
send_mail("Test subject", "Test content", ["*****@*****.**"])
# Check that the email was sent
self.assertEqual(len(mail.outbox), 1)
self.assertEqual(mail.outbox[0].subject, "Test subject")
self.assertEqual(mail.outbox[0].body, "Test content")
self.assertEqual(mail.outbox[0].to, ["*****@*****.**"])
self.assertEqual(mail.outbox[0].from_email, "*****@*****.**")
def test_send_default_from_email(self):
send_mail("Test subject", "Test content", ["*****@*****.**"])
# Check that the email was sent
self.assertEqual(len(mail.outbox), 1)
self.assertEqual(mail.outbox[0].subject, "Test subject")
self.assertEqual(mail.outbox[0].body, "Test content")
self.assertEqual(mail.outbox[0].to, ["*****@*****.**"])
self.assertEqual(mail.outbox[0].from_email, "webmaster@localhost")
def send_mail(self, form):
addresses = [x.strip() for x in self.to_address.split(',')]
content = []
for field in form:
value = field.value()
if isinstance(value, list):
value = ', '.join(value)
content.append('{}: {}'.format(field.label, value))
content = '\n'.join(content)
send_mail(self.subject, content, addresses, self.from_address,)
def send_mail(self, form):
subject = f"[Contact Us] {form.data['subject']}"
addresses = [x.strip() for x in self.to_address.split(',')]
send_mail(
subject,
self.render_email(form),
addresses,
self.from_address,
)
def send_mail(self, form):
# `self` is the FormPage, `form` is the form's POST data on submit
print(dir(self))
addresses = [form['podpisatsia-na-rassylku'].value()]
subject = "Благодарим за доверие"
content = "Мы благодарим вас за подписку на email рассылку. Мы будем очень аккуратно и редко отправлять концентрированную информацию вам"
send_mail(subject, content, addresses, self.from_address)
# Email addresses are parsed from the FormPage's addresses field
addresses = [x.strip() for x in self.to_address.split(',')]
subject = self.subject
content = "Новая подписка на email с сайта ecolabomsk.ru"
send_mail(subject, content, addresses, self.from_address)
def send_share_email(self):
"""
Emails the user with the review link
"""
email_address = self.external_user.email
review_token = Token(self.external_user.get_reviewer(), self.page.get_latest_revision())
email_body = render_to_string('wagtail_review/email/share.txt', {
'page': self.page,
'review_url': get_review_url(review_token),
})
send_mail("A page has been shared with you", email_body, [email_address])
def process_form_submission(self, form):
form_submission = self.get_submission_class().objects.create(
form_data=json.dumps(form.cleaned_data, cls=DjangoJSONEncoder),
page=self, user=form.user
)
if self.to_address:
addresses = [x.strip() for x in self.to_address.split(',')]
content = '\n'.join([x[1].label + ': ' + str(form.data.get(x[0])) for x in form.fields.items()])
send_mail(self.subject, content, addresses, self.from_address,)
# process_form_submission should now return the created form_submission
return form_submission
def send_mail(self, form):
"""Overrides default send_mail function in wagtail.
Added submission date and url to where form was submitted."""
addresses = [x.strip() for x in self.to_address.split(',')]
content = []
for field in form:
value = field.value()
if isinstance(value, list):
value = ', '.join(value)
content.append('{}: {}'.format(field.label, value))
submitted_date_str = date.today().strftime('%x')
content.append('{}: {}'.format('Submitted', submitted_date_str))
content = '\n'.join(content) + "\n"
subject = self.subject + " - " + submitted_date_str
send_mail(subject, content, addresses, self.from_address)
def send_emails(self, template_set, context, recipients, **kwargs):
connection = get_connection()
sent_count = 0
try:
with OpenedConnection(connection) as open_connection:
# Send emails
for recipient in recipients:
try:
# update context with this recipient
context["user"] = recipient.internal
context["reviewer"] = recipient
context["review_url"] = get_review_url(Token(recipient, context["revision"]))
# Translate text to the recipient language settings
if recipient.internal:
with override(recipient.internal.wagtail_userprofile.get_preferred_language()):
# Get email subject and content
email_subject = render_to_string(template_set['subject'], context).strip()
email_content = render_to_string(template_set['text'], context).strip()
else:
email_subject = render_to_string(template_set['subject'], context).strip()
email_content = render_to_string(template_set['text'], context).strip()
kwargs = {}
if getattr(settings, 'WAGTAILADMIN_NOTIFICATION_USE_HTML', False):
kwargs['html_message'] = render_to_string(template_set['html'], context)
# Send email
send_mail(email_subject, email_content, [recipient.get_email()], connection=open_connection, **kwargs)
sent_count += 1
except Exception:
logger.exception(
"Failed to send notification email '%s' to %s",
email_subject, recipient.email
)
except (TimeoutError, ConnectionError):
logger.exception("Mail connection error, notification sending skipped")
return sent_count == len(recipients)
def send_request_emails(self):
# send request emails to all reviewers except the reviewer record for the user submitting the request
for reviewer in self.assignees.all():
email = reviewer.get_email()
context = {
'email': email,
'user': reviewer.internal,
'reviewer': reviewer,
'review_request': self,
'page': self.page_revision.as_page_object(),
'submitter': self.submitted_by,
'review_url': self.get_review_url(reviewer),
}
email_subject = render_to_string('wagtail_review/email/request_review_subject.txt', context).strip()
email_content = render_to_string('wagtail_review/email/request_review.txt', context).strip()
send_mail(email_subject, email_content, [email])
def send_mail(self, form):
addresses = [x.strip() for x in self.to_address.split(',')]
emailheader = "New registration via Pharmaziegasse Website"
content = []
for field in form:
value = field.value()
if isinstance(value, list):
value = ', '.join(value)
content.append('{}: {}'.format(field.label, value))
content = '\n'.join(content)
content += '\n\nMade with ❤ by a tiny SNEK'
#emailfooter = '<style>@keyframes pulse { 10% { color: red; } }</style><p>Made with <span style="width: 20px; height: 1em; color:#dd0000; animation: pulse 1s infinite;">❤</span> by <a style="color: lightgrey" href="https://www.aichner-christian.com" target="_blank">Werbeagentur Christian Aichner</a></p>'
#html_message = f"{emailheader}\n\n{content}\n\n{emailfooter}"
send_mail(self.subject, f"{emailheader}\n\n{content}", addresses, self.from_address)
def handle(self, value):
form = self.context['form']
form_name = form.name
subject = _(f'Odpověď na formulář "{form_name}"')
sender_field_name = value['sender']
validated_data = self.context['validated_data']
sender = validated_data.get(sender_field_name, None)
if sender is None and self.context['request'].user.is_authenticated:
sender = self.context['request'].user.email
context = {
'user': self.context['request'].user,
'data': validated_data,
'context': {}
}
msg_html = render_to_string('send_email_action.html', context)
send_mail(subject=subject,
message=str(validated_data),
from_email=sender,
recipient_list=[value['address']],
html_message=msg_html)
def send_mail(self, form):
addresses = []
addresses.append(self.to_address)
submitted_date_str = date.today().strftime('%x')
subject = 'Contact Request - ' + submitted_date_str
content = ['Submission content below -\n', ]
for field in form:
# add the value of each field as a new line
value = field.value()
if isinstance(value, list):
value = ', '.join(value)
content.append('{}: {}'.format(field.label, value))
# Content is joined with a new line to separate each text line
content = '\n'.join(content)
# wagtail.wagtailadmin.utils - send_mail function is called
# This function extends the Django default send_mail function
send_mail(subject, content, addresses, self.from_address)
def process_form_submission(self, form):
form_submission = self.get_submission_class().objects.create(
form_data=form.cleaned_data,
page=self,
user=form.user,
)
if self.to_address:
addresses = [x.strip() for x in self.to_address.split(",")]
content = "\n".join([
x[1].label + ": " + str(form.data.get(x[0]))
for x in form.fields.items()
])
send_mail(
self.subject,
content,
addresses,
self.from_address,
)
# process_form_submission should now return the created form_submission
return form_submission
def send_mail(self, form):
addresses = [x.strip() for x in self.to_address.split(',')]
context = {
'subject': self.subject,
'title': self.title,
'render_data': []
}
for field in form:
value = field.value()
if isinstance(value, list):
value = ', '.join(value)
context['render_data'].append({
'title': field.label,
'data': value
})
html_message = render_to_string('form_email.html', context)
plain_message = strip_tags(html_message)
send_mail(self.subject,
plain_message,
addresses,
self.from_address,
html_message=html_message,
fail_silently=False)
