def render(self, plain_body: str, plain_signature: str, subject: str,
order, position) -> str:
body_md = markdown_compile_email(plain_body)
htmlctx = {
'site': settings.PRETIX_INSTANCE_NAME,
'site_url': settings.SITE_URL,
'body': body_md,
'subject': str(subject),
'color': '#8E44B3',
'rtl': get_language() in settings.LANGUAGES_RTL
}
if self.event:
htmlctx['event'] = self.event
htmlctx['color'] = self.event.settings.primary_color
if plain_signature:
signature_md = plain_signature.replace('\n', '<br>\n')
signature_md = markdown_compile_email(signature_md)
htmlctx['signature'] = signature_md
if order:
htmlctx['order'] = order
if position:
htmlctx['position'] = position
tpl = get_template(self.template_name)
body_html = inline_css(tpl.render(htmlctx))
return body_html
def render(self, plain_body: str, plain_signature: str, subject: str, order: Order, position: OrderPosition) -> str:
body_md = markdown_compile_email(plain_body)
htmlctx = {
'site': settings.PRETIX_INSTANCE_NAME,
'site_url': settings.SITE_URL,
'body': body_md,
'subject': str(subject),
'color': '#8E44B3'
}
if self.event:
htmlctx['event'] = self.event
htmlctx['color'] = self.event.settings.primary_color
if plain_signature:
signature_md = plain_signature.replace('\n', '<br>\n')
signature_md = markdown_compile_email(signature_md)
htmlctx['signature'] = signature_md
if order:
htmlctx['order'] = order
if position:
htmlctx['position'] = position
tpl = get_template(self.template_name)
body_html = inline_css(tpl.render(htmlctx))
return body_html
def render(self, plain_body: str, plain_signature: str, subject: str, order, position) -> str:
body_md = markdown_compile_email(plain_body)
htmlctx = {
'site': settings.PRETIX_INSTANCE_NAME,
'site_url': settings.SITE_URL,
'body': body_md,
'subject': str(subject),
'color': settings.PRETIX_PRIMARY_COLOR,
'rtl': get_language() in settings.LANGUAGES_RTL or get_language().split('-')[0] in settings.LANGUAGES_RTL,
}
if self.organizer:
htmlctx['organizer'] = self.organizer
if self.event:
htmlctx['event'] = self.event
htmlctx['color'] = self.event.settings.primary_color
if plain_signature:
signature_md = plain_signature.replace('\n', '<br>\n')
signature_md = markdown_compile_email(signature_md)
htmlctx['signature'] = signature_md
if order:
htmlctx['order'] = order
positions = list(order.positions.select_related(
'item', 'variation', 'subevent', 'addon_to'
).annotate(
has_addons=Count('addons')
))
htmlctx['cart'] = [(k, list(v)) for k, v in groupby(
sorted(
positions,
key=lambda op: (
(op.addon_to.positionid if op.addon_to_id else op.positionid),
op.positionid
)
),
key=lambda op: (
op.item,
op.variation,
op.subevent,
op.attendee_name,
op.addon_to_id,
(op.pk if op.has_addons else None)
)
)]
if position:
htmlctx['position'] = position
htmlctx['ev'] = position.subevent or self.event
tpl = get_template(self.template_name)
body_html = tpl.render(htmlctx)
inliner = css_inline.CSSInliner(remove_style_tags=True)
body_html = inliner.inline(body_html)
return body_html
def get_context_data(self, **kwargs):
ctx = super().get_context_data(**kwargs)
o = {}
for lang in self.request.event.settings.locales:
with language(lang, self.request.event.settings.region):
placeholders = TolerantDict()
for k, v in get_available_placeholders(self.request.event, ['event', 'order', 'position_or_address']).items():
placeholders[k] = '<span class="placeholder" title="{}">{}</span>'.format(
_('This value will be replaced based on dynamic parameters.'),
v.render_sample(self.request.event)
)
subject = bleach.clean(self.object.subject.localize(lang), tags=[])
preview_subject = subject.format_map(placeholders)
template = self.object.template.localize(lang)
preview_text = markdown_compile_email(template.format_map(placeholders))
o[lang] = {
'subject': _('Subject: {subject}'.format(subject=preview_subject)),
'html': preview_text,
}
ctx['output'] = o
return ctx
def form_valid(self, form):
self.output = {}
if self.request.POST.get("action") == "preview":
for l in self.request.event.settings.locales:
with language(l, self.request.event.settings.region):
context_dict = TolerantDict()
for k, v in get_available_placeholders(
self.request.event,
['event', 'order', 'position_or_address']).items():
context_dict[
k] = '<span class="placeholder" title="{}">{}</span>'.format(
_('This value will be replaced based on dynamic parameters.'
), v.render_sample(self.request.event))
subject = bleach.clean(
form.cleaned_data['subject'].localize(l), tags=[])
preview_subject = subject.format_map(context_dict)
template = form.cleaned_data['template'].localize(l)
preview_text = markdown_compile_email(
template.format_map(context_dict))
self.output[l] = {
'subject':
_('Subject: {subject}').format(
subject=preview_subject),
'html':
preview_text,
}
return self.get(self.request, *self.args, **self.kwargs)
messages.success(self.request, _('Your rule has been created.'))
form.instance.event = self.request.event
self.object = form.save()
return redirect(
'plugins:sendmail:rule.update',
event=self.request.event.slug,
organizer=self.request.event.organizer.slug,
rule=self.object.pk,
)
def form_valid(self, form):
qs = Order.objects.filter(event=self.request.event)
statusq = Q(status__in=form.cleaned_data['sendto'])
if 'overdue' in form.cleaned_data['sendto']:
statusq |= Q(status=Order.STATUS_PENDING, expires__lt=now())
orders = qs.filter(statusq)
orders = orders.filter(all_positions__item_id__in=[i.pk for i in form.cleaned_data.get('items')],
all_positions__canceled=False)
if form.cleaned_data.get('subevent'):
orders = orders.filter(all_positions__subevent__in=(form.cleaned_data.get('subevent'),),
all_positions__canceled=False)
orders = orders.distinct()
self.output = {}
if not orders:
messages.error(self.request, _('There are no orders matching this selection.'))
return self.get(self.request, *self.args, **self.kwargs)
if self.request.POST.get("action") == "preview":
for l in self.request.event.settings.locales:
with language(l):
context_dict = {
'code': 'ORDER1234',
'event': self.request.event.name,
'date': date_format(now(), 'SHORT_DATE_FORMAT'),
'expire_date': date_format(now() + timedelta(days=7), 'SHORT_DATE_FORMAT'),
'url': build_absolute_uri(self.request.event, 'presale:event.order.open', kwargs={
'order': 'ORDER1234',
'secret': 'longrandomsecretabcdef123456',
'hash': 'abcdef',
}),
'invoice_name': _('John Doe'),
'invoice_company': _('Sample Company LLC')
}
subject = form.cleaned_data['subject'].localize(l)
preview_subject = subject.format_map(context_dict)
message = form.cleaned_data['message'].localize(l)
preview_text = markdown_compile_email(message.format_map(context_dict))
self.output[l] = {
'subject': _('Subject: {subject}').format(subject=preview_subject),
'html': preview_text,
}
return self.get(self.request, *self.args, **self.kwargs)
send_mails.apply_async(
kwargs={
'recipients': form.cleaned_data['recipients'],
'event': self.request.event.pk,
'user': self.request.user.pk,
'subject': form.cleaned_data['subject'].data,
'message': form.cleaned_data['message'].data,
'orders': [o.pk for o in orders],
'items': [i.pk for i in form.cleaned_data.get('items')]
}
)
self.request.event.log_action('pretix.plugins.sendmail.sent',
user=self.request.user,
data=dict(form.cleaned_data))
messages.success(self.request, _('Your message has been queued and will be sent to the contact addresses of %d '
'orders in the next minutes.') % len(orders))
return redirect(
'plugins:sendmail:send',
event=self.request.event.slug,
organizer=self.request.event.organizer.slug
)
def form_valid(self, form):
qs = Order.objects.filter(event=self.request.event)
statusq = Q(status__in=form.cleaned_data['sendto'])
if 'overdue' in form.cleaned_data['sendto']:
statusq |= Q(status=Order.STATUS_PENDING, expires__lt=now())
orders = qs.filter(statusq)
opq = OrderPosition.objects.filter(
order=OuterRef('pk'),
canceled=False,
item_id__in=[i.pk for i in form.cleaned_data.get('items')],
)
if form.cleaned_data.get('filter_checkins'):
ql = []
if form.cleaned_data.get('not_checked_in'):
ql.append(Q(checkins__list_id=None))
if form.cleaned_data.get('checkin_lists'):
ql.append(
Q(checkins__list_id__in=[
i.pk
for i in form.cleaned_data.get('checkin_lists', [])
], ))
if len(ql) == 2:
opq = opq.filter(ql[0] | ql[1])
elif ql:
opq = opq.filter(ql[0])
else:
opq = opq.none()
if form.cleaned_data.get('subevent'):
opq = opq.filter(subevent=form.cleaned_data.get('subevent'))
orders = orders.annotate(match_pos=Exists(opq)).filter(
match_pos=True).distinct()
self.output = {}
if not orders:
messages.error(self.request,
_('There are no orders matching this selection.'))
return self.get(self.request, *self.args, **self.kwargs)
if self.request.POST.get("action") == "preview":
for l in self.request.event.settings.locales:
with language(l):
context_dict = TolerantDict()
for k, v in get_available_placeholders(
self.request.event,
['event', 'order', 'position_or_address']).items():
context_dict[
k] = '<span class="placeholder" title="{}">{}</span>'.format(
_('This value will be replaced based on dynamic parameters.'
), v.render_sample(self.request.event))
subject = bleach.clean(
form.cleaned_data['subject'].localize(l), tags=[])
preview_subject = subject.format_map(context_dict)
message = form.cleaned_data['message'].localize(l)
preview_text = markdown_compile_email(
message.format_map(context_dict))
self.output[l] = {
'subject':
_('Subject: {subject}').format(
subject=preview_subject),
'html':
preview_text,
}
return self.get(self.request, *self.args, **self.kwargs)
send_mails.apply_async(
kwargs={
'recipients':
form.cleaned_data['recipients'],
'event':
self.request.event.pk,
'user':
self.request.user.pk,
'subject':
form.cleaned_data['subject'].data,
'message':
form.cleaned_data['message'].data,
'orders': [o.pk for o in orders],
'items': [i.pk for i in form.cleaned_data.get('items')],
'not_checked_in':
form.cleaned_data.get('not_checked_in'),
'checkin_lists':
[i.pk for i in form.cleaned_data.get('checkin_lists')],
'filter_checkins':
form.cleaned_data.get('filter_checkins'),
})
self.request.event.log_action('pretix.plugins.sendmail.sent',
user=self.request.user,
data=dict(form.cleaned_data))
messages.success(
self.request,
_('Your message has been queued and will be sent to the contact addresses of %d '
'orders in the next minutes.') % len(orders))
return redirect('plugins:sendmail:send',
event=self.request.event.slug,
organizer=self.request.event.organizer.slug)
def form_valid(self, form):
qs = Order.objects.filter(event=self.request.event)
statusq = Q(status__in=form.cleaned_data['sendto'])
if 'overdue' in form.cleaned_data['sendto']:
statusq |= Q(status=Order.STATUS_PENDING, expires__lt=now())
orders = qs.filter(statusq)
orders = orders.filter(all_positions__item_id__in=[
i.pk for i in form.cleaned_data.get('items')
],
all_positions__canceled=False)
if form.cleaned_data.get('subevent'):
orders = orders.filter(all_positions__subevent__in=(
form.cleaned_data.get('subevent'), ),
all_positions__canceled=False)
orders = orders.distinct()
self.output = {}
if not orders:
messages.error(self.request,
_('There are no orders matching this selection.'))
return self.get(self.request, *self.args, **self.kwargs)
if self.request.POST.get("action") == "preview":
for l in self.request.event.settings.locales:
with language(l):
context_dict = {
'code':
'ORDER1234',
'event':
self.request.event.name,
'date':
date_format(now(), 'SHORT_DATE_FORMAT'),
'expire_date':
date_format(now() + timedelta(days=7),
'SHORT_DATE_FORMAT'),
'url':
build_absolute_uri(self.request.event,
'presale:event.order.open',
kwargs={
'order': 'ORDER1234',
'secret':
'longrandomsecretabcdef123456',
'hash': 'abcdef',
}),
'invoice_name':
_('John Doe'),
'invoice_company':
_('Sample Company LLC')
}
subject = form.cleaned_data['subject'].localize(l)
preview_subject = subject.format_map(context_dict)
message = form.cleaned_data['message'].localize(l)
preview_text = markdown_compile_email(
message.format_map(context_dict))
self.output[l] = {
'subject':
_('Subject: {subject}').format(
subject=preview_subject),
'html':
preview_text,
}
return self.get(self.request, *self.args, **self.kwargs)
send_mails.apply_async(
kwargs={
'recipients': form.cleaned_data['recipients'],
'event': self.request.event.pk,
'user': self.request.user.pk,
'subject': form.cleaned_data['subject'].data,
'message': form.cleaned_data['message'].data,
'orders': [o.pk for o in orders],
'items': [i.pk for i in form.cleaned_data.get('items')]
})
self.request.event.log_action('pretix.plugins.sendmail.sent',
user=self.request.user,
data=dict(form.cleaned_data))
messages.success(
self.request,
_('Your message has been queued and will be sent to the contact addresses of %d '
'orders in the next minutes.') % len(orders))
return redirect('plugins:sendmail:send',
event=self.request.event.slug,
organizer=self.request.event.organizer.slug)
def test_linkify_abs(link):
input, output = link
assert rich_text_snippet(input, safelinks=False) == output
assert rich_text(input, safelinks=False) == f'<p>{output}</p>'
assert markdown_compile_email(input) == f'<p>{output}</p>'
def form_valid(self, form):
self.output = {}
recipients = form.cleaned_data.get('recipients')
if not recipients:
messages.error(self.request,
_('You have not provided any recipients.'))
return self.get(self.request, *self.args, **self.kwargs)
# normalize voucher templates in subject and message
i18n_subject = {}
i18n_message = {}
for l in self.request.event.settings.locales:
with language(l):
i18n_subject[l] = normalize_voucher_template(
str(form.cleaned_data['subject']))
i18n_message[l] = normalize_voucher_template(
str(form.cleaned_data['message']))
subject = LazyI18nString(i18n_subject)
message = LazyI18nString(i18n_message)
# generate preview
if self.request.POST.get("action") == "preview":
for l in self.request.event.settings.locales:
with language(l):
try:
vouchers = build_voucher_template_dict(
self.request.event,
str(subject) + str(message))
except NoMatchingVoucher:
messages.error(
self.request,
_('There are not enough vouchers to fill the template.'
))
return self.get(self.request, *self.args,
**self.kwargs)
context_dict = {
'event': self.request.event.name,
'voucher': vouchers
}
preview_subject = str(subject).format_map(context_dict)
preview_text = markdown_compile_email(
str(message).format_map(context_dict))
self.output[l] = {
'subject':
_('Subject: {subject}').format(
subject=preview_subject),
'html':
preview_text,
}
return self.get(self.request, *self.args, **self.kwargs)
# collect vouchers
vouchers = {l: [] for l in self.request.event.settings.locales}
vouchers.update({None: []})
try:
with transaction.atomic():
for r in recipients:
if isinstance(r, tuple):
locale, email_address = r
else:
locale = None
email_address = r
with language(locale):
v = build_voucher_template_dict(
self.request.event,
str(subject) + str(message),
how_shared=email_address)
vouchers[locale].append(v)
except NoMatchingVoucher:
messages.error(
self.request,
_('There are not enough vouchers to fill the template.'))
return self.get(self.request, *self.args, **self.kwargs)
# send e-mails
send_mails.apply_async(
kwargs={
'recipients': recipients,
'vouchers': vouchers,
'event': self.request.event.pk,
'user': self.request.user.pk,
'subject': subject.data,
'message': message.data,
})
self.request.event.log_action('pretix_send_vouchers.email.sent',
user=self.request.user,
data=dict(form.cleaned_data))
messages.success(
self.request,
_('Your message has been queued and will be sent to the provided addresses in the next minutes.'
))
return redirect('plugins:pretix_send_vouchers:send',
event=self.request.event.slug,
organizer=self.request.event.organizer.slug)
