def event_index(request, organizer, event):
subevent = None
if request.GET.get("subevent", "") != "" and request.event.has_subevents:
i = request.GET.get("subevent", "")
try:
subevent = request.event.subevents.get(pk=i)
except SubEvent.DoesNotExist:
pass
widgets = []
for r, result in event_dashboard_widgets.send(sender=request.event, subevent=subevent):
widgets.extend(result)
can_change_orders = request.user.has_event_permission(request.organizer, request.event, 'can_change_orders',
request=request)
qs = request.event.logentry_set.all().select_related('user', 'content_type', 'api_token', 'oauth_application',
'device').order_by('-datetime')
qs = qs.exclude(action_type__in=OVERVIEW_BLACKLIST)
if not request.user.has_event_permission(request.organizer, request.event, 'can_view_orders', request=request):
qs = qs.exclude(content_type=ContentType.objects.get_for_model(Order))
if not request.user.has_event_permission(request.organizer, request.event, 'can_view_vouchers', request=request):
qs = qs.exclude(content_type=ContentType.objects.get_for_model(Voucher))
a_qs = request.event.requiredaction_set.filter(done=False)
ctx = {
'widgets': rearrange(widgets),
'logs': qs[:5],
'actions': a_qs[:5] if can_change_orders else [],
'comment_form': CommentForm(initial={'comment': request.event.comment})
}
ctx['has_overpaid_orders'] = Order.annotate_overpayments(request.event.orders).filter(
Q(~Q(status=Order.STATUS_CANCELED) & Q(pending_sum_t__lt=0))
| Q(Q(status=Order.STATUS_CANCELED) & Q(pending_sum_rc__lt=0))
).exists()
ctx['has_pending_orders_with_full_payment'] = Order.annotate_overpayments(request.event.orders).filter(
Q(status__in=(Order.STATUS_EXPIRED, Order.STATUS_PENDING)) & Q(pending_sum_t__lte=0) & Q(require_approval=False)
).exists()
ctx['has_pending_refunds'] = OrderRefund.objects.filter(
order__event=request.event,
state__in=(OrderRefund.REFUND_STATE_CREATED, OrderRefund.REFUND_STATE_EXTERNAL)
).exists()
ctx['has_pending_approvals'] = request.event.orders.filter(
status=Order.STATUS_PENDING,
require_approval=True
).exists()
for a in ctx['actions']:
a.display = a.display(request)
return render(request, 'pretixcontrol/event/index.html', ctx)
def event_index(request, organizer, event):
subevent = None
if request.GET.get("subevent", "") != "" and request.event.has_subevents:
i = request.GET.get("subevent", "")
try:
subevent = request.event.subevents.get(pk=i)
except SubEvent.DoesNotExist:
pass
widgets = []
for r, result in event_dashboard_widgets.send(sender=request.event, subevent=subevent):
widgets.extend(result)
can_change_orders = request.user.has_event_permission(request.organizer, request.event, 'can_change_orders',
request=request)
qs = request.event.logentry_set.all().select_related('user', 'content_type', 'api_token', 'oauth_application',
'device').order_by('-datetime')
qs = qs.exclude(action_type__in=OVERVIEW_BLACKLIST)
if not request.user.has_event_permission(request.organizer, request.event, 'can_view_orders', request=request):
qs = qs.exclude(content_type=ContentType.objects.get_for_model(Order))
if not request.user.has_event_permission(request.organizer, request.event, 'can_view_vouchers', request=request):
qs = qs.exclude(content_type=ContentType.objects.get_for_model(Voucher))
a_qs = request.event.requiredaction_set.filter(done=False)
ctx = {
'widgets': rearrange(widgets),
'logs': qs[:5],
'actions': a_qs[:5] if can_change_orders else [],
'comment_form': CommentForm(initial={'comment': request.event.comment})
}
ctx['has_overpaid_orders'] = Order.annotate_overpayments(request.event.orders).filter(
Q(~Q(status__in=(Order.STATUS_REFUNDED, Order.STATUS_CANCELED)) & Q(pending_sum_t__lt=0))
| Q(Q(status__in=(Order.STATUS_REFUNDED, Order.STATUS_CANCELED)) & Q(pending_sum_rc__lt=0))
).exists()
ctx['has_pending_orders_with_full_payment'] = Order.annotate_overpayments(request.event.orders).filter(
Q(status__in=(Order.STATUS_EXPIRED, Order.STATUS_PENDING)) & Q(pending_sum_t__lte=0) & Q(require_approval=False)
).exists()
ctx['has_pending_refunds'] = OrderRefund.objects.filter(
order__event=request.event,
state__in=(OrderRefund.REFUND_STATE_CREATED, OrderRefund.REFUND_STATE_EXTERNAL)
).exists()
ctx['has_pending_approvals'] = request.event.orders.filter(
status=Order.STATUS_PENDING,
require_approval=True
).exists()
for a in ctx['actions']:
a.display = a.display(request)
return render(request, 'pretixcontrol/event/index.html', ctx)
def get_context_data(self, **kwargs):
ctx = super().get_context_data(**kwargs)
ctx['customer'] = self.request.customer
ctx['memberships'] = self.request.customer.memberships.with_usages().select_related(
'membership_type', 'granted_in', 'granted_in__order', 'granted_in__order__event'
)
ctx['invoice_addresses'] = InvoiceAddress.profiles.filter(customer=self.request.customer)
ctx['is_paginated'] = True
for m in ctx['memberships']:
if m.membership_type.max_usages:
m.percent = int(m.usages / m.membership_type.max_usages * 100)
else:
m.percent = 0
s = OrderPosition.objects.filter(
order=OuterRef('pk')
).order_by().values('order').annotate(k=Count('id')).values('k')
annotated = {
o['pk']: o
for o in
Order.annotate_overpayments(Order.objects, sums=True).filter(
pk__in=[o.pk for o in ctx['orders']]
).annotate(
pcnt=Subquery(s, output_field=IntegerField()),
).values(
'pk', 'pcnt',
)
}
for o in ctx['orders']:
if o.pk not in annotated:
continue
o.count_positions = annotated.get(o.pk)['pcnt']
return ctx
def get_context_data(self, **kwargs):
ctx = super().get_context_data()
ctx['filter_form'] = self.filter_form
ctx['meta_fields'] = [
self.filter_form[k] for k in self.filter_form.fields
if k.startswith('meta_')
]
# Only compute this annotations for this page (query optimization)
s = OrderPosition.objects.filter(
order=OuterRef('pk')).order_by().values('order').annotate(
k=Count('id')).values('k')
annotated = {
o['pk']: o
for o in Order.annotate_overpayments(Order.objects).using(
settings.DATABASE_REPLICA).filter(
pk__in=[o.pk for o in ctx['orders']]).annotate(
pcnt=Subquery(s, output_field=IntegerField()),
has_cancellation_request=Exists(
CancellationRequest.objects.filter(
order=OuterRef('pk')))).
values('pk', 'pcnt', 'is_overpaid', 'is_underpaid',
'is_pending_with_full_payment', 'has_external_refund',
'has_pending_refund', 'has_cancellation_request')
}
for o in ctx['orders']:
if o.pk not in annotated:
continue
o.pcnt = annotated.get(o.pk)['pcnt']
o.is_overpaid = annotated.get(o.pk)['is_overpaid']
o.is_underpaid = annotated.get(o.pk)['is_underpaid']
o.is_pending_with_full_payment = annotated.get(
o.pk)['is_pending_with_full_payment']
o.has_external_refund = annotated.get(o.pk)['has_external_refund']
o.has_pending_refund = annotated.get(o.pk)['has_pending_refund']
o.has_cancellation_request = annotated.get(
o.pk)['has_cancellation_request']
return ctx
def filter_qs(self, qs):
fdata = self.cleaned_data
if fdata.get('query'):
u = fdata.get('query')
if "-" in u:
code = (Q(event__slug__icontains=u.rsplit("-", 1)[0])
& Q(code__icontains=Order.normalize_code(u.rsplit("-", 1)[1])))
else:
code = Q(code__icontains=Order.normalize_code(u))
matching_invoices = Invoice.objects.filter(
Q(invoice_no__iexact=u)
| Q(invoice_no__iexact=u.zfill(5))
| Q(full_invoice_no__iexact=u)
).values_list('order_id', flat=True)
matching_positions = OrderPosition.objects.filter(
Q(
Q(attendee_name_cached__icontains=u) | Q(attendee_email__icontains=u)
| Q(secret__istartswith=u)
| Q(pseudonymization_id__istartswith=u)
)
).values_list('order_id', flat=True)
matching_invoice_addresses = InvoiceAddress.objects.filter(
Q(
Q(name_cached__icontains=u) | Q(company__icontains=u)
)
).values_list('order_id', flat=True)
matching_orders = Order.objects.filter(
code
| Q(email__icontains=u)
| Q(comment__icontains=u)
).values_list('id', flat=True)
mainq = (
Q(pk__in=matching_orders)
| Q(pk__in=matching_invoices)
| Q(pk__in=matching_positions)
| Q(pk__in=matching_invoice_addresses)
| Q(pk__in=matching_invoices)
)
for recv, q in order_search_filter_q.send(sender=getattr(self, 'event', None), query=u):
mainq = mainq | q
qs = qs.filter(
mainq
)
if fdata.get('status'):
s = fdata.get('status')
if s == 'o':
qs = qs.filter(status=Order.STATUS_PENDING, expires__lt=now().replace(hour=0, minute=0, second=0))
elif s == 'np':
qs = qs.filter(status__in=[Order.STATUS_PENDING, Order.STATUS_PAID])
elif s == 'ne':
qs = qs.filter(status__in=[Order.STATUS_PENDING, Order.STATUS_EXPIRED])
elif s in ('p', 'n', 'e', 'c', 'r'):
qs = qs.filter(status=s)
elif s == 'overpaid':
qs = Order.annotate_overpayments(qs, refunds=False, results=False, sums=True)
qs = qs.filter(
Q(~Q(status=Order.STATUS_CANCELED) & Q(pending_sum_t__lt=0))
| Q(Q(status=Order.STATUS_CANCELED) & Q(pending_sum_rc__lt=0))
)
elif s == 'rc':
qs = qs.filter(
cancellation_requests__isnull=False
)
elif s == 'pendingpaid':
qs = Order.annotate_overpayments(qs, refunds=False, results=False, sums=True)
qs = qs.filter(
Q(status__in=(Order.STATUS_EXPIRED, Order.STATUS_PENDING)) & Q(pending_sum_t__lte=0)
& Q(require_approval=False)
)
elif s == 'underpaid':
qs = Order.annotate_overpayments(qs, refunds=False, results=False, sums=True)
qs = qs.filter(
status=Order.STATUS_PAID,
pending_sum_t__gt=0
)
elif s == 'pa':
qs = qs.filter(
status=Order.STATUS_PENDING,
require_approval=True
)
elif s == 'testmode':
qs = qs.filter(
testmode=True
)
elif s == 'cp':
s = OrderPosition.objects.filter(
order=OuterRef('pk')
)
qs = qs.annotate(
has_pc=Exists(s)
).filter(
Q(status=Order.STATUS_PAID, has_pc=False) | Q(status=Order.STATUS_CANCELED)
)
if fdata.get('ordering'):
qs = qs.order_by(self.get_order_by())
if fdata.get('provider'):
qs = qs.annotate(
has_payment_with_provider=Exists(
OrderPayment.objects.filter(
Q(order=OuterRef('pk')) & Q(provider=fdata.get('provider'))
)
)
)
qs = qs.filter(has_payment_with_provider=1)
return qs
def filter_qs(self, qs):
fdata = self.cleaned_data
qs = super().filter_qs(qs)
item = fdata.get('item')
if item:
if '-' in item:
var = item.split('-')[1]
qs = qs.filter(all_positions__variation_id=var,
all_positions__canceled=False).distinct()
else:
qs = qs.filter(all_positions__item_id=fdata.get('item'),
all_positions__canceled=False).distinct()
if fdata.get('subevent'):
qs = qs.filter(all_positions__subevent=fdata.get('subevent'),
all_positions__canceled=False).distinct()
if fdata.get('question') and fdata.get('answer') is not None:
q = fdata.get('question')
if q.type == Question.TYPE_FILE:
answers = QuestionAnswer.objects.filter(
orderposition__order_id=OuterRef('pk'),
question_id=q.pk,
file__isnull=False)
qs = qs.annotate(has_answer=Exists(answers)).filter(
has_answer=True)
elif q.type in (Question.TYPE_CHOICE,
Question.TYPE_CHOICE_MULTIPLE):
answers = QuestionAnswer.objects.filter(
question_id=q.pk,
orderposition__order_id=OuterRef('pk'),
options__pk=fdata.get('answer'))
qs = qs.annotate(has_answer=Exists(answers)).filter(
has_answer=True)
else:
answers = QuestionAnswer.objects.filter(
question_id=q.pk,
orderposition__order_id=OuterRef('pk'),
answer__iexact=fdata.get('answer'))
qs = qs.annotate(has_answer=Exists(answers)).filter(
has_answer=True)
if fdata.get('status') == 'overpaid':
qs = Order.annotate_overpayments(qs,
refunds=False,
results=False,
sums=True)
qs = qs.filter(
Q(~Q(status=Order.STATUS_CANCELED) & Q(pending_sum_t__lt=0))
| Q(Q(status=Order.STATUS_CANCELED) & Q(pending_sum_rc__lt=0)))
elif fdata.get('status') == 'pendingpaid':
qs = Order.annotate_overpayments(qs,
refunds=False,
results=False,
sums=True)
qs = qs.filter(
Q(status__in=(Order.STATUS_EXPIRED, Order.STATUS_PENDING))
& Q(pending_sum_t__lte=0)
& Q(require_approval=False))
elif fdata.get('status') == 'underpaid':
qs = Order.annotate_overpayments(qs,
refunds=False,
results=False,
sums=True)
qs = qs.filter(status=Order.STATUS_PAID, pending_sum_t__gt=0)
elif fdata.get('status') == 'pa':
qs = qs.filter(status=Order.STATUS_PENDING, require_approval=True)
elif fdata.get('status') == 'testmode':
qs = qs.filter(testmode=True)
elif fdata.get('status') == 'cp':
s = OrderPosition.objects.filter(order=OuterRef('pk'))
qs = qs.annotate(has_pc=Exists(s)).filter(
Q(status=Order.STATUS_PAID, has_pc=False)
| Q(status=Order.STATUS_CANCELED))
return qs
def event_index(request, organizer, event):
subevent = None
if request.GET.get("subevent", "") != "" and request.event.has_subevents:
i = request.GET.get("subevent", "")
try:
subevent = request.event.subevents.get(pk=i)
except SubEvent.DoesNotExist:
pass
can_view_orders = request.user.has_event_permission(request.organizer,
request.event,
'can_view_orders',
request=request)
can_change_event_settings = request.user.has_event_permission(
request.organizer,
request.event,
'can_change_event_settings',
request=request)
widgets = []
if can_view_orders:
for r, result in event_dashboard_widgets.send(sender=request.event,
subevent=subevent,
lazy=True):
widgets.extend(result)
ctx = {
'widgets':
rearrange(widgets),
'subevent':
subevent,
'comment_form':
CommentForm(initial={'comment': request.event.comment},
readonly=not can_change_event_settings),
}
ctx['has_overpaid_orders'] = can_view_orders and Order.annotate_overpayments(
request.event.orders).filter(
Q(~Q(status=Order.STATUS_CANCELED) & Q(pending_sum_t__lt=0))
| Q(Q(status=Order.STATUS_CANCELED)
& Q(pending_sum_rc__lt=0))).exists()
ctx['has_pending_orders_with_full_payment'] = can_view_orders and Order.annotate_overpayments(
request.event.orders).filter(
Q(status__in=(Order.STATUS_EXPIRED, Order.STATUS_PENDING))
& Q(pending_sum_t__lte=0) & Q(require_approval=False)).exists()
ctx['has_pending_refunds'] = can_view_orders and OrderRefund.objects.filter(
order__event=request.event,
state__in=(OrderRefund.REFUND_STATE_CREATED,
OrderRefund.REFUND_STATE_EXTERNAL)).exists()
ctx['has_pending_approvals'] = can_view_orders and request.event.orders.filter(
status=Order.STATUS_PENDING, require_approval=True).exists()
ctx['has_cancellation_requests'] = can_view_orders and CancellationRequest.objects.filter(
order__event=request.event).exists()
ctx['timeline'] = [{
'date':
t.datetime.astimezone(request.event.timezone).date(),
'entry':
t,
'time':
t.datetime.astimezone(request.event.timezone)
} for t in timeline_for_event(request.event, subevent)]
ctx['today'] = now().astimezone(request.event.timezone).date()
ctx['nearly_now'] = now().astimezone(
request.event.timezone) - timedelta(seconds=20)
resp = render(request, 'pretixcontrol/event/index.html', ctx)
# resp['Content-Security-Policy'] = "style-src 'unsafe-inline'"
return resp
def event_index(request, organizer, event):
subevent = None
if request.GET.get("subevent", "") != "" and request.event.has_subevents:
i = request.GET.get("subevent", "")
try:
subevent = request.event.subevents.get(pk=i)
except SubEvent.DoesNotExist:
pass
can_view_orders = request.user.has_event_permission(request.organizer,
request.event,
'can_view_orders',
request=request)
can_change_orders = request.user.has_event_permission(request.organizer,
request.event,
'can_change_orders',
request=request)
can_change_event_settings = request.user.has_event_permission(
request.organizer,
request.event,
'can_change_event_settings',
request=request)
can_view_vouchers = request.user.has_event_permission(request.organizer,
request.event,
'can_view_vouchers',
request=request)
widgets = []
if can_view_orders:
for r, result in event_dashboard_widgets.send(sender=request.event,
subevent=subevent,
lazy=True):
widgets.extend(result)
qs = request.event.logentry_set.all().select_related(
'user', 'content_type', 'api_token', 'oauth_application',
'device').order_by('-datetime')
qs = qs.exclude(action_type__in=OVERVIEW_BANLIST)
if not can_view_orders:
qs = qs.exclude(content_type=ContentType.objects.get_for_model(Order))
if not can_view_vouchers:
qs = qs.exclude(
content_type=ContentType.objects.get_for_model(Voucher))
if not can_change_event_settings:
allowed_types = [
ContentType.objects.get_for_model(Voucher),
ContentType.objects.get_for_model(Order)
]
if request.user.has_event_permission(request.organizer,
request.event,
'can_change_items',
request=request):
allowed_types += [
ContentType.objects.get_for_model(Item),
ContentType.objects.get_for_model(ItemCategory),
ContentType.objects.get_for_model(Quota),
ContentType.objects.get_for_model(Question),
]
qs = qs.filter(content_type__in=allowed_types)
a_qs = request.event.requiredaction_set.filter(done=False)
ctx = {
'widgets':
rearrange(widgets),
'logs':
qs[:5],
'subevent':
subevent,
'actions':
a_qs[:5] if can_change_orders else [],
'comment_form':
CommentForm(initial={'comment': request.event.comment},
readonly=not can_change_event_settings),
}
ctx['has_overpaid_orders'] = can_view_orders and Order.annotate_overpayments(
request.event.orders).filter(
Q(~Q(status=Order.STATUS_CANCELED) & Q(pending_sum_t__lt=0))
| Q(Q(status=Order.STATUS_CANCELED)
& Q(pending_sum_rc__lt=0))).exists()
ctx['has_pending_orders_with_full_payment'] = can_view_orders and Order.annotate_overpayments(
request.event.orders).filter(
Q(status__in=(Order.STATUS_EXPIRED, Order.STATUS_PENDING))
& Q(pending_sum_t__lte=0) & Q(require_approval=False)).exists()
ctx['has_pending_refunds'] = can_view_orders and OrderRefund.objects.filter(
order__event=request.event,
state__in=(OrderRefund.REFUND_STATE_CREATED,
OrderRefund.REFUND_STATE_EXTERNAL)).exists()
ctx['has_pending_approvals'] = can_view_orders and request.event.orders.filter(
status=Order.STATUS_PENDING, require_approval=True).exists()
ctx['has_cancellation_requests'] = can_view_orders and CancellationRequest.objects.filter(
order__event=request.event).exists()
for a in ctx['actions']:
a.display = a.display(request)
ctx['timeline'] = [{
'date':
t.datetime.astimezone(request.event.timezone).date(),
'entry':
t,
'time':
t.datetime.astimezone(request.event.timezone)
} for t in timeline_for_event(request.event, subevent)]
ctx['today'] = now().astimezone(request.event.timezone).date()
ctx['nearly_now'] = now().astimezone(
request.event.timezone) - timedelta(seconds=20)
resp = render(request, 'pretixcontrol/event/index.html', ctx)
# resp['Content-Security-Policy'] = "style-src 'unsafe-inline'"
return resp
def filter_qs(self, qs):
fdata = self.cleaned_data
qs = super().filter_qs(qs)
if fdata.get('item'):
qs = qs.filter(all_positions__item=fdata.get('item'), all_positions__canceled=False).distinct()
if fdata.get('subevent'):
qs = qs.filter(all_positions__subevent=fdata.get('subevent'), all_positions__canceled=False).distinct()
if fdata.get('question') and fdata.get('answer') is not None:
q = fdata.get('question')
if q.type == Question.TYPE_FILE:
answers = QuestionAnswer.objects.filter(
orderposition__order_id=OuterRef('pk'),
question_id=q.pk,
file__isnull=False
)
qs = qs.annotate(has_answer=Exists(answers)).filter(has_answer=True)
elif q.type in (Question.TYPE_CHOICE, Question.TYPE_CHOICE_MULTIPLE):
answers = QuestionAnswer.objects.filter(
question_id=q.pk,
orderposition__order_id=OuterRef('pk'),
options__pk=fdata.get('answer')
)
qs = qs.annotate(has_answer=Exists(answers)).filter(has_answer=True)
else:
answers = QuestionAnswer.objects.filter(
question_id=q.pk,
orderposition__order_id=OuterRef('pk'),
answer__iexact=fdata.get('answer')
)
qs = qs.annotate(has_answer=Exists(answers)).filter(has_answer=True)
if fdata.get('status') == 'overpaid':
qs = Order.annotate_overpayments(qs, refunds=False, results=False, sums=True)
qs = qs.filter(
Q(~Q(status=Order.STATUS_CANCELED) & Q(pending_sum_t__lt=0))
| Q(Q(status=Order.STATUS_CANCELED) & Q(pending_sum_rc__lt=0))
)
elif fdata.get('status') == 'pendingpaid':
qs = Order.annotate_overpayments(qs, refunds=False, results=False, sums=True)
qs = qs.filter(
Q(status__in=(Order.STATUS_EXPIRED, Order.STATUS_PENDING)) & Q(pending_sum_t__lte=0)
& Q(require_approval=False)
)
elif fdata.get('status') == 'underpaid':
qs = Order.annotate_overpayments(qs, refunds=False, results=False, sums=True)
qs = qs.filter(
status=Order.STATUS_PAID,
pending_sum_t__gt=0
)
elif fdata.get('status') == 'pa':
qs = qs.filter(
status=Order.STATUS_PENDING,
require_approval=True
)
elif fdata.get('status') == 'testmode':
qs = qs.filter(
testmode=True
)
elif fdata.get('status') == 'cp':
s = OrderPosition.objects.filter(
order=OuterRef('pk')
)
qs = qs.annotate(
has_pc=Exists(s)
).filter(
Q(status=Order.STATUS_PAID, has_pc=False) | Q(status=Order.STATUS_CANCELED)
)
return qs
