def get_context_data(self, **kwargs):
ctx = super().get_context_data(**kwargs)
ctx['order'] = self.order
can_download = all([r for rr, r in allow_ticket_download.send(self.request.event, order=self.order)])
if self.request.event.settings.ticket_download_date:
ctx['ticket_download_date'] = self.order.ticket_download_date
ctx['can_download'] = can_download and self.order.ticket_download_available
ctx['download_buttons'] = self.download_buttons
ctx['cart'] = self.get_cart(
answers=True, downloads=ctx['can_download'],
queryset=self.order.positions.select_related('tax_rule'),
order=self.order
)
ctx['can_download_multi'] = any([b['multi'] for b in self.download_buttons]) and (
self.request.event.settings.ticket_download_nonadm or
[p.item.admission for p in ctx['cart']['positions']].count(True) > 1
)
ctx['invoices'] = list(self.order.invoices.all())
can_generate_invoice = (
self.request.event.settings.get('invoice_generate') in ('user', 'True')
or (
self.request.event.settings.get('invoice_generate') == 'paid'
and self.order.status == Order.STATUS_PAID
)
)
ctx['can_generate_invoice'] = invoice_qualified(self.order) and can_generate_invoice
ctx['url'] = build_absolute_uri(
self.request.event, 'presale:event.order', kwargs={
'order': self.order.code,
'secret': self.order.secret
}
)
if self.order.status == Order.STATUS_PENDING:
ctx['pending_sum'] = self.order.pending_sum
lp = self.order.payments.last()
ctx['can_pay'] = False
for provider in self.request.event.get_payment_providers().values():
if provider.is_enabled and provider.order_change_allowed(self.order):
ctx['can_pay'] = True
break
if lp and lp.state not in (OrderPayment.PAYMENT_STATE_CONFIRMED, OrderPayment.PAYMENT_STATE_REFUNDED):
ctx['last_payment'] = self.order.payments.last()
pp = lp.payment_provider
ctx['last_payment_info'] = pp.payment_pending_render(self.request, ctx['last_payment'])
if lp.state == OrderPayment.PAYMENT_STATE_PENDING and not pp.abort_pending_allowed:
ctx['can_pay'] = False
ctx['can_pay'] = ctx['can_pay'] and self.order._can_be_paid() is True
elif self.order.status == Order.STATUS_PAID:
ctx['can_pay'] = False
return ctx
def output(self):
if not all([r for rr, r in allow_ticket_download.send(self.request.event, order=self.order)]):
return None
responses = register_ticket_outputs.send(self.request.event)
for receiver, response in responses:
provider = response(self.request.event)
if provider.identifier == self.kwargs.get('output'):
return provider
def output(self):
if not all([
r for rr, r in allow_ticket_download.send(self.request.event,
order=self.order)
]):
return None
responses = register_ticket_outputs.send(self.request.event)
for receiver, response in responses:
provider = response(self.request.event)
if provider.identifier == self.kwargs.get('output'):
return provider
def get_context_data(self, **kwargs):
ctx = super().get_context_data(**kwargs)
ctx['order'] = self.order
can_download = all([r for rr, r in allow_ticket_download.send(self.request.event, order=self.order)])
if self.request.event.settings.ticket_download_date:
ctx['ticket_download_date'] = self.order.ticket_download_date
ctx['can_download'] = (
can_download and self.request.event.settings.ticket_download
and (
self.request.event.settings.ticket_download_date is None
or now() > self.order.ticket_download_date
) and self.order.status == Order.STATUS_PAID
)
ctx['download_buttons'] = self.download_buttons
ctx['cart'] = self.get_cart(
answers=True, downloads=ctx['can_download'],
queryset=self.order.positions.select_related('tax_rule'),
order=self.order
)
ctx['can_download_multi'] = any([b['multi'] for b in self.download_buttons]) and (
self.request.event.settings.ticket_download_nonadm or
[p.item.admission for p in ctx['cart']['positions']].count(True) > 1
)
ctx['invoices'] = list(self.order.invoices.all())
ctx['can_generate_invoice'] = invoice_qualified(self.order) and (
self.request.event.settings.invoice_generate == 'user'
)
ctx['url'] = build_absolute_uri(
self.request.event, 'presale:event.order', kwargs={
'order': self.order.code,
'secret': self.order.secret
}
)
if self.order.status == Order.STATUS_PENDING:
ctx['payment'] = self.payment_provider.order_pending_render(self.request, self.order)
ctx['can_retry'] = (
self.payment_provider.order_can_retry(self.order)
and self.payment_provider.is_enabled
and self.order._can_be_paid()
)
ctx['can_change_method'] = False
for provider in self.request.event.get_payment_providers().values():
if (provider.identifier != self.order.payment_provider and provider.is_enabled
and provider.order_change_allowed(self.order)):
ctx['can_change_method'] = True
break
elif self.order.status == Order.STATUS_PAID:
ctx['payment'] = self.payment_provider.order_paid_render(self.request, self.order)
ctx['can_retry'] = False
return ctx
def get_tickets_for_order(order):
can_download = all(
[r for rr, r in allow_ticket_download.send(order.event, order=order)])
if not can_download:
return []
if not order.ticket_download_available:
return []
providers = [
response(order.event)
for receiver, response in register_ticket_outputs.send(order.event)
]
tickets = []
for p in providers:
if not p.is_enabled:
continue
if p.multi_download_enabled:
try:
ct = get_cachedticket_for_order(order,
p.identifier,
generate_async=False)
tickets.append(("{}-{}-{}{}".format(
order.event.slug.upper(),
order.code,
ct.provider,
ct.extension,
), ct))
except:
logger.exception('Failed to generate ticket.')
else:
for pos in order.positions.all():
if pos.addon_to and not order.event.settings.ticket_download_addons:
continue
if not pos.item.admission and not order.event.settings.ticket_download_nonadm:
continue
try:
ct = get_cachedticket_for_position(pos,
p.identifier,
generate_async=False)
tickets.append(("{}-{}-{}-{}{}".format(
order.event.slug.upper(),
order.code,
pos.positionid,
ct.provider,
ct.extension,
), ct))
except:
logger.exception('Failed to generate ticket.')
return tickets
def get_tickets_for_order(order):
can_download = all([r for rr, r in allow_ticket_download.send(order.event, order=order)])
if not can_download:
return []
if not order.ticket_download_available:
return []
providers = [
response(order.event)
for receiver, response
in register_ticket_outputs.send(order.event)
]
tickets = []
for p in providers:
if not p.is_enabled:
continue
if p.multi_download_enabled:
try:
ct = get_cachedticket_for_order(order, p.identifier, generate_async=False)
tickets.append((
"{}-{}-{}{}".format(
order.event.slug.upper(), order.code, ct.provider, ct.extension,
),
ct
))
except:
logger.exception('Failed to generate ticket.')
else:
for pos in order.positions.all():
if pos.addon_to and not order.event.settings.ticket_download_addons:
continue
if not pos.item.admission and not order.event.settings.ticket_download_nonadm:
continue
try:
ct = get_cachedticket_for_position(pos, p.identifier, generate_async=False)
tickets.append((
"{}-{}-{}-{}{}".format(
order.event.slug.upper(), order.code, pos.positionid, ct.provider, ct.extension,
),
ct
))
except:
logger.exception('Failed to generate ticket.')
return tickets
def get_context_data(self, **kwargs):
ctx = super().get_context_data(**kwargs)
ctx['order'] = self.order
can_download = all([r for rr, r in allow_ticket_download.send(self.request.event, order=self.order)])
if self.request.event.settings.ticket_download_date:
ctx['ticket_download_date'] = self.order.ticket_download_date
ctx['can_download'] = can_download and self.order.ticket_download_available and self.order.positions_with_tickets
ctx['download_buttons'] = self.download_buttons
ctx['backend_user'] = (
self.request.user.is_authenticated
and self.request.user.has_event_permission(self.request.organizer, self.request.event, 'can_view_orders', request=self.request)
)
return ctx
def get_context_data(self, **kwargs):
ctx = super().get_context_data(**kwargs)
ctx['order'] = self.order
can_download = all([r for rr, r in allow_ticket_download.send(self.request.event, order=self.order)])
if self.request.event.settings.ticket_download_date:
ctx['ticket_download_date'] = self.order.ticket_download_date
ctx['can_download'] = can_download and self.order.ticket_download_available and self.order.positions_with_tickets
ctx['download_buttons'] = self.download_buttons
ctx['backend_user'] = (
self.request.user.is_authenticated
and self.request.user.has_event_permission(self.request.organizer, self.request.event, 'can_view_orders', request=self.request)
)
return ctx
def send_download_reminders(sender, **kwargs):
today = now().replace(hour=0, minute=0, second=0, microsecond=0)
for e in Event.objects.filter(date_from__gte=today):
days = e.settings.get('mail_days_download_reminder', as_type=int)
if days is None:
continue
reminder_date = (e.date_from - timedelta(days=days)).replace(
hour=0, minute=0, second=0, microsecond=0)
if now() < reminder_date:
continue
for o in e.orders.filter(status=Order.STATUS_PAID,
download_reminder_sent=False):
if not all([r
for rr, r in allow_ticket_download.send(e, order=o)]):
continue
o.download_reminder_sent = True
o.save()
email_template = e.settings.mail_text_download_reminder
email_context = {
'event':
o.event.name,
'url':
build_absolute_uri(o.event,
'presale:event.order',
kwargs={
'order': o.code,
'secret': o.secret
}),
}
email_subject = _(
'Your ticket is ready for download: %(code)s') % {
'code': o.code
}
try:
o.send_mail(email_subject, email_template, email_context,
'pretix.event.order.email.expire_warning_sent')
except SendMailException:
logger.exception('Reminder email could not be sent')
def get_context_data(self, **kwargs):
ctx = super().get_context_data(**kwargs)
ctx['order'] = self.order
can_download = all([
r for rr, r in allow_ticket_download.send(self.request.event,
order=self.order)
])
if self.request.event.settings.ticket_download_date:
ctx['ticket_download_date'] = self.order.ticket_download_date
ctx['can_download'] = (
can_download and self.request.event.settings.ticket_download
and (self.request.event.settings.ticket_download_date is None
or now() > self.order.ticket_download_date)
and self.order.status == Order.STATUS_PAID)
ctx['download_buttons'] = self.download_buttons
ctx['cart'] = self.get_cart(
answers=True,
downloads=ctx['can_download'],
queryset=self.order.positions.select_related('tax_rule'),
order=self.order)
ctx['can_download_multi'] = any([
b['multi'] for b in self.download_buttons
]) and (self.request.event.settings.ticket_download_nonadm
or [p.item.admission
for p in ctx['cart']['positions']].count(True) > 1)
ctx['invoices'] = list(self.order.invoices.all())
can_generate_invoice = (
self.request.event.settings.get('invoice_generate')
in ('user', 'True')
or (self.request.event.settings.get('invoice_generate') == 'paid'
and self.order.status == Order.STATUS_PAID))
ctx['can_generate_invoice'] = invoice_qualified(
self.order) and can_generate_invoice
ctx['url'] = build_absolute_uri(self.request.event,
'presale:event.order',
kwargs={
'order': self.order.code,
'secret': self.order.secret
})
if self.order.status == Order.STATUS_PENDING:
ctx['pending_sum'] = self.order.pending_sum
lp = self.order.payments.last()
ctx['can_pay'] = False
for provider in self.request.event.get_payment_providers().values(
):
if provider.is_enabled and provider.order_change_allowed(
self.order):
ctx['can_pay'] = True
break
if lp and lp.state not in (OrderPayment.PAYMENT_STATE_CONFIRMED,
OrderPayment.PAYMENT_STATE_REFUNDED):
ctx['last_payment'] = self.order.payments.last()
pp = lp.payment_provider
ctx['last_payment_info'] = pp.payment_pending_render(
self.request, ctx['last_payment'])
if lp.state == OrderPayment.PAYMENT_STATE_PENDING and not pp.abort_pending_allowed:
ctx['can_pay'] = False
ctx['can_pay'] = ctx['can_pay'] and self.order._can_be_paid(
) is True
elif self.order.status == Order.STATUS_PAID:
ctx['can_pay'] = False
return ctx
def get_tickets_for_order(order, base_position=None):
can_download = all(
[r for rr, r in allow_ticket_download.send(order.event, order=order)])
if not can_download:
return []
if not order.ticket_download_available:
return []
providers = [
response(order.event)
for receiver, response in register_ticket_outputs.send(order.event)
]
tickets = []
positions = list(order.positions_with_tickets)
if base_position:
# Only the given position and its children
positions = [
p for p in positions
if p.pk == base_position.pk or p.addon_to_id == base_position.pk
]
for p in providers:
if not p.is_enabled:
continue
if p.multi_download_enabled and not base_position:
try:
if len(positions) == 0:
continue
ct = CachedCombinedTicket.objects.filter(
order=order, provider=p.identifier,
file__isnull=False).last()
if not ct or not ct.file:
retval = generate_order(order.pk, p.identifier)
if not retval:
continue
ct = CachedCombinedTicket.objects.get(pk=retval)
tickets.append(("{}-{}-{}{}".format(
order.event.slug.upper(),
order.code,
ct.provider,
ct.extension,
), ct))
except:
logger.exception('Failed to generate ticket.')
else:
for pos in positions:
try:
ct = CachedTicket.objects.filter(
order_position=pos,
provider=p.identifier,
file__isnull=False).last()
if not ct or not ct.file:
retval = generate_orderposition(pos.pk, p.identifier)
if not retval:
continue
ct = CachedTicket.objects.get(pk=retval)
if ct.type == 'text/uri-list':
continue
if pos.subevent:
# Subevent date in filename improves accessibility e.g. for screen reader users
fname = "{}-{}-{}-{}-{}{}".format(
order.event.slug.upper(), order.code,
pos.positionid,
pos.subevent.date_from.strftime('%Y_%m_%d'),
ct.provider, ct.extension)
else:
fname = "{}-{}-{}-{}{}".format(
order.event.slug.upper(), order.code,
pos.positionid, ct.provider, ct.extension)
tickets.append((fname, ct))
except:
logger.exception('Failed to generate ticket.')
return tickets
def get_tickets_for_order(order):
can_download = all(
[r for rr, r in allow_ticket_download.send(order.event, order=order)])
if not can_download:
return []
if not order.ticket_download_available:
return []
providers = [
response(order.event)
for receiver, response in register_ticket_outputs.send(order.event)
]
tickets = []
for p in providers:
if not p.is_enabled:
continue
if p.multi_download_enabled:
try:
ct = CachedCombinedTicket.objects.filter(
order=order, provider=p.identifier,
file__isnull=False).last()
if not ct or not ct.file:
retval = generate.apply(args=('order', order.pk,
p.identifier))
ct = CachedCombinedTicket.objects.get(pk=retval.value)
tickets.append(("{}-{}-{}{}".format(
order.event.slug.upper(),
order.code,
ct.provider,
ct.extension,
), ct))
except:
logger.exception('Failed to generate ticket.')
else:
for pos in order.positions.all():
if pos.addon_to and not order.event.settings.ticket_download_addons:
continue
if not pos.item.admission and not order.event.settings.ticket_download_nonadm:
continue
try:
ct = CachedTicket.objects.filter(
order_position=pos,
provider=p.identifier,
file__isnull=False).last()
if not ct or not ct.file:
retval = generate.apply(args=('orderposition', pos.pk,
p.identifier))
ct = CachedTicket.objects.get(pk=retval.value)
tickets.append(("{}-{}-{}-{}{}".format(
order.event.slug.upper(),
order.code,
pos.positionid,
ct.provider,
ct.extension,
), ct))
except:
logger.exception('Failed to generate ticket.')
return tickets
def get_context_data(self, **kwargs):
ctx = super().get_context_data(**kwargs)
ctx['order'] = self.order
can_download = all([
r for rr, r in allow_ticket_download.send(self.request.event,
order=self.order)
])
if self.request.event.settings.ticket_download_date:
ctx['ticket_download_date'] = self.order.ticket_download_date
ctx['can_download'] = can_download and self.order.ticket_download_available and self.order.positions_with_tickets
ctx['download_buttons'] = self.download_buttons
ctx['cart'] = self.get_cart(
answers=True,
downloads=ctx['can_download'],
queryset=self.order.positions.select_related('tax_rule'),
order=self.order)
ctx['can_download_multi'] = any([
b['multi'] for b in self.download_buttons
]) and ([p.generate_ticket
for p in ctx['cart']['positions']].count(True) > 1)
ctx['invoices'] = list(self.order.invoices.all())
can_generate_invoice = (
self.request.event.settings.get('invoice_generate')
in ('user', 'True')
or (self.request.event.settings.get('invoice_generate') == 'paid'
and self.order.status == Order.STATUS_PAID))
ctx['can_generate_invoice'] = invoice_qualified(
self.order) and can_generate_invoice
ctx['url'] = build_absolute_uri(self.request.event,
'presale:event.order',
kwargs={
'order': self.order.code,
'secret': self.order.secret
})
ctx['invoice_address_asked'] = self.request.event.settings.invoice_address_asked and (
self.order.total != Decimal('0.00')
or not self.request.event.settings.invoice_address_not_asked_free)
ctx['backend_user'] = (self.request.user.is_authenticated
and self.request.user.has_event_permission(
self.request.organizer,
self.request.event,
'can_view_orders',
request=self.request))
if self.order.status == Order.STATUS_PENDING:
ctx['pending_sum'] = self.order.pending_sum
lp = self.order.payments.last()
ctx['can_pay'] = False
for provider in self.request.event.get_payment_providers().values(
):
if provider.is_enabled and provider.order_change_allowed(
self.order):
ctx['can_pay'] = True
break
if lp and lp.state not in (OrderPayment.PAYMENT_STATE_CONFIRMED,
OrderPayment.PAYMENT_STATE_REFUNDED):
ctx['last_payment'] = self.order.payments.last()
pp = lp.payment_provider
ctx['last_payment_info'] = pp.payment_pending_render(
self.request, ctx['last_payment'])
if lp.state == OrderPayment.PAYMENT_STATE_PENDING and not pp.abort_pending_allowed:
ctx['can_pay'] = False
ctx['can_pay'] = ctx['can_pay'] and self.order._can_be_paid(
) is True
elif self.order.status == Order.STATUS_PAID:
ctx['can_pay'] = False
ctx['refunds'] = self.order.refunds.filter(
state__in=(OrderRefund.REFUND_STATE_DONE,
OrderRefund.REFUND_STATE_TRANSIT,
OrderRefund.REFUND_STATE_CREATED))
return ctx
def get_tickets_for_order(order, base_position=None):
can_download = all([r for rr, r in allow_ticket_download.send(order.event, order=order)])
if not can_download:
return []
if not order.ticket_download_available:
return []
providers = [
response(order.event)
for receiver, response
in register_ticket_outputs.send(order.event)
]
tickets = []
positions = list(order.positions_with_tickets)
if base_position:
# Only the given position and its children
positions = [
p for p in positions if p.pk == base_position.pk or p.addon_to_id == base_position.pk
]
for p in providers:
if not p.is_enabled:
continue
if p.multi_download_enabled and not base_position:
try:
if len(positions) == 0:
continue
ct = CachedCombinedTicket.objects.filter(
order=order, provider=p.identifier, file__isnull=False
).last()
if not ct or not ct.file:
retval = generate_order(order.pk, p.identifier)
if not retval:
continue
ct = CachedCombinedTicket.objects.get(pk=retval)
tickets.append((
"{}-{}-{}{}".format(
order.event.slug.upper(), order.code, ct.provider, ct.extension,
),
ct
))
except:
logger.exception('Failed to generate ticket.')
else:
for pos in positions:
try:
ct = CachedTicket.objects.filter(
order_position=pos, provider=p.identifier, file__isnull=False
).last()
if not ct or not ct.file:
retval = generate_orderposition(pos.pk, p.identifier)
if not retval:
continue
ct = CachedTicket.objects.get(pk=retval)
tickets.append((
"{}-{}-{}-{}{}".format(
order.event.slug.upper(), order.code, pos.positionid, ct.provider, ct.extension,
),
ct
))
except:
logger.exception('Failed to generate ticket.')
return tickets
