def send_mail(self,
subject: str,
template: Union[str, LazyI18nString],
context: Dict[str, Any] = None,
log_entry_type: str = 'pretix.event.order.email.sent',
user: User = None,
headers: dict = None,
sender: str = None,
invoices: list = None):
"""
Sends an email to the user that placed this order. Basically, this method does two things:
* Call ``pretix.base.services.mail.mail`` with useful values for the ``event``, ``locale``, ``recipient`` and
``order`` parameters.
* Create a ``LogEntry`` with the email contents.
:param subject: Subject of the email
:param template: LazyI18nString or template filename, see ``pretix.base.services.mail.mail`` for more details
:param context: Dictionary to use for rendering the template
:param log_entry_type: Key to be used for the log entry
:param user: Administrative user who triggered this mail to be sent
:param headers: Dictionary with additional mail headers
:param sender: Custom email sender.
"""
from pretix.base.services.mail import SendMailException, mail, render_mail
if not self.email:
return
with language(self.locale):
recipient = self.email
try:
email_content = render_mail(template, context)[0]
mail(recipient,
subject,
template,
context,
self.event,
self.locale,
self,
headers,
sender,
invoices=invoices)
except SendMailException:
raise
else:
self.log_action(log_entry_type,
user=user,
data={
'subject':
subject,
'message':
email_content,
'recipient':
recipient,
'invoices':
[i.pk
for i in invoices] if invoices else []
})
def twilio_order_message(order, template_name):
from .tasks import twilio_send
recipient = order.phone
if not order.phone:
return
context = get_email_context(event=order.event, order=order)
for k, v in order.event.meta_data.items():
context["meta_" + k] = v
with language(order.locale, order.event.settings.region):
template = order.event.settings.get(f"twilio_text_{template_name}")
if not str(template):
return
try:
content = render_mail(template, context)
twilio_send(text=content, to=str(recipient), event=order.event_id)
except Exception:
raise
else:
order.log_action(
"pretix_twilio.message.sent",
data={
"message": content,
"recipient": str(recipient),
},
)
def form_valid(self, form):
tz = pytz.timezone(self.request.event.settings.timezone)
order = Order.objects.get(event=self.request.event,
code=self.kwargs['code'].upper())
self.preview_output = {}
try:
invoice_name = order.invoice_address.name
invoice_company = order.invoice_address.company
except InvoiceAddress.DoesNotExist:
invoice_name = ""
invoice_company = ""
with language(order.locale):
email_context = {
'event':
order.event,
'code':
order.code,
'date':
date_format(order.datetime.astimezone(tz),
'SHORT_DATETIME_FORMAT'),
'expire_date':
date_format(order.expires, 'SHORT_DATE_FORMAT'),
'url':
build_absolute_uri(order.event,
'presale:event.order',
kwargs={
'order': order.code,
'secret': order.secret
}),
'invoice_name':
invoice_name,
'invoice_company':
invoice_company,
}
email_template = LazyI18nString(form.cleaned_data['message'])
email_content = render_mail(email_template, email_context)[0]
if self.request.POST.get('action') == 'preview':
self.preview_output = []
self.preview_output.append(
_('Subject: {subject}').format(
subject=form.cleaned_data['subject']))
self.preview_output.append(email_content)
return self.get(self.request, *self.args, **self.kwargs)
else:
try:
order.send_mail(form.cleaned_data['subject'], email_template,
email_context,
'pretix.event.order.email.custom_sent',
self.request.user)
messages.success(
self.request,
_('Your message has been queued and will be sent to {}.'.
format(order.email)))
except SendMailException:
messages.error(
self.request,
_('Failed to send mail to the following user: {}'.format(
order.email)))
return super(OrderSendMail, self).form_valid(form)
