forked from CGM_Public/pretix_original
431 lines
16 KiB
Python
431 lines
16 KiB
Python
import json
|
|
import logging
|
|
import urllib.parse
|
|
|
|
import dateutil.parser
|
|
from django.contrib import messages
|
|
from django.core.exceptions import ValidationError
|
|
from django.db.models import Count, Max, OuterRef, Q, Subquery
|
|
from django.http import (
|
|
HttpResponseForbidden, HttpResponseNotFound, JsonResponse,
|
|
)
|
|
from django.shortcuts import get_object_or_404, redirect
|
|
from django.urls import reverse
|
|
from django.utils.decorators import method_decorator
|
|
from django.utils.functional import cached_property
|
|
from django.utils.timezone import now
|
|
from django.utils.translation import ugettext_lazy as _
|
|
from django.views.decorators.csrf import csrf_exempt
|
|
from django.views.generic import TemplateView, View
|
|
|
|
from pretix.base.models import Checkin, Event, Order, OrderPosition
|
|
from pretix.base.models.event import SubEvent
|
|
from pretix.base.services.checkin import (
|
|
CheckInError, RequiredQuestionsError, perform_checkin,
|
|
)
|
|
from pretix.control.permissions import EventPermissionRequiredMixin
|
|
from pretix.helpers.urls import build_absolute_uri
|
|
from pretix.multidomain.urlreverse import (
|
|
build_absolute_uri as event_absolute_uri,
|
|
)
|
|
from pretix.plugins.pretixdroid.forms import AppConfigurationForm
|
|
from pretix.plugins.pretixdroid.models import AppConfiguration
|
|
|
|
logger = logging.getLogger('pretix.plugins.pretixdroid')
|
|
API_VERSION = 3
|
|
|
|
|
|
class ConfigCodeView(EventPermissionRequiredMixin, TemplateView):
|
|
template_name = 'pretixplugins/pretixdroid/configuration_code.html'
|
|
permission = 'can_change_orders'
|
|
|
|
def get(self, request, **kwargs):
|
|
try:
|
|
self.object = self.request.event.appconfiguration_set.get(pk=kwargs.get("config"))
|
|
except AppConfiguration.DoesNotExist:
|
|
messages.error(request, _('The selected configuration does not exist.'))
|
|
return redirect(reverse('plugins:pretixdroid:config', kwargs={
|
|
'organizer': self.request.event.organizer.slug,
|
|
'event': self.request.event.slug,
|
|
}))
|
|
return super().get(request, **kwargs)
|
|
|
|
def get_context_data(self, **kwargs):
|
|
ctx = super().get_context_data()
|
|
url = build_absolute_uri('plugins:pretixdroid:api.redeem', kwargs={
|
|
'organizer': self.request.event.organizer.slug,
|
|
'event': self.request.event.slug
|
|
})
|
|
if self.object.subevent:
|
|
url = build_absolute_uri('plugins:pretixdroid:api.redeem', kwargs={
|
|
'organizer': self.request.event.organizer.slug,
|
|
'event': self.request.event.slug,
|
|
'subevent': self.object.subevent.pk
|
|
})
|
|
|
|
data = {
|
|
'version': API_VERSION,
|
|
'url': url[:-7], # the slice removes the redeem/ part at the end
|
|
'key': self.object.key,
|
|
'allow_search': self.object.allow_search,
|
|
'show_info': self.object.show_info
|
|
}
|
|
ctx['config'] = self.object
|
|
ctx['query'] = urllib.parse.urlencode(data, safe=':/')
|
|
ctx['qrdata'] = json.dumps(data)
|
|
return ctx
|
|
|
|
|
|
class ConfigView(EventPermissionRequiredMixin, TemplateView):
|
|
template_name = 'pretixplugins/pretixdroid/configuration.html'
|
|
permission = 'can_change_orders'
|
|
|
|
@cached_property
|
|
def add_form(self):
|
|
return AppConfigurationForm(
|
|
event=self.request.event,
|
|
instance=AppConfiguration(event=self.request.event),
|
|
data=self.request.POST if self.request.method == "POST" and "add" in self.request.POST else None
|
|
)
|
|
|
|
def post(self, request, *args, **kwargs):
|
|
if "add" in self.request.POST and self.add_form.is_valid():
|
|
self.add_form.save()
|
|
self.request.event.log_action('pretix.plugins.pretixdroid.config.added', user=self.request.user,
|
|
data=dict(self.add_form.cleaned_data))
|
|
return redirect(reverse('plugins:pretixdroid:config.code', kwargs={
|
|
'organizer': self.request.event.organizer.slug,
|
|
'event': self.request.event.slug,
|
|
'config': self.add_form.instance.pk
|
|
}))
|
|
elif "delete" in self.request.POST:
|
|
try:
|
|
ac = self.request.event.appconfiguration_set.get(pk=request.POST.get("delete"))
|
|
self.request.event.log_action('pretix.plugins.pretixdroid.config.deleted', user=self.request.user,
|
|
data={'id': ac.pk})
|
|
ac.delete()
|
|
messages.success(request, _('The selected configuration has been deleted.'))
|
|
except AppConfiguration.DoesNotExist:
|
|
messages.error(request, _('The selected configuration does not exist.'))
|
|
return redirect(reverse('plugins:pretixdroid:config', kwargs={
|
|
'organizer': self.request.event.organizer.slug,
|
|
'event': self.request.event.slug,
|
|
}))
|
|
else:
|
|
return self.get(request, *args, **kwargs)
|
|
|
|
def get_context_data(self, **kwargs):
|
|
ctx = super().get_context_data()
|
|
ctx['add_form'] = self.add_form
|
|
ctx['configs'] = self.request.event.appconfiguration_set.select_related('list').prefetch_related('items')
|
|
return ctx
|
|
|
|
|
|
class ApiView(View):
|
|
@method_decorator(csrf_exempt)
|
|
def dispatch(self, request, **kwargs):
|
|
try:
|
|
self.event = Event.objects.get(
|
|
slug=self.kwargs['event'],
|
|
organizer__slug=self.kwargs['organizer']
|
|
)
|
|
except Event.DoesNotExist:
|
|
return HttpResponseNotFound('Unknown event')
|
|
|
|
try:
|
|
self.config = self.event.appconfiguration_set.get(key=request.GET.get("key", "-unset-"))
|
|
except AppConfiguration.DoesNotExist:
|
|
return HttpResponseForbidden('Invalid key')
|
|
|
|
self.subevent = None
|
|
if self.event.has_subevents:
|
|
if self.config.list.subevent:
|
|
self.subevent = self.config.list.subevent
|
|
if 'subevent' in kwargs and kwargs['subevent'] != str(self.subevent.pk):
|
|
return HttpResponseForbidden('Invalid subevent selected.')
|
|
elif 'subevent' in kwargs:
|
|
self.subevent = get_object_or_404(SubEvent, event=self.event, pk=kwargs['subevent'])
|
|
else:
|
|
return HttpResponseForbidden('No subevent selected.')
|
|
else:
|
|
if 'subevent' in kwargs:
|
|
return HttpResponseForbidden('Subevents not enabled.')
|
|
|
|
return super().dispatch(request, **kwargs)
|
|
|
|
|
|
class ApiRedeemView(ApiView):
|
|
def post(self, request, **kwargs):
|
|
secret = request.POST.get('secret', '!INVALID!')
|
|
force = request.POST.get('force', 'false') in ('true', 'True')
|
|
ignore_unpaid = request.POST.get('ignore_unpaid', 'false') in ('true', 'True')
|
|
nonce = request.POST.get('nonce')
|
|
response = {
|
|
'version': API_VERSION
|
|
}
|
|
|
|
if 'datetime' in request.POST:
|
|
dt = dateutil.parser.parse(request.POST.get('datetime'))
|
|
else:
|
|
dt = now()
|
|
|
|
try:
|
|
op = OrderPosition.objects.get(order__event=self.event, secret=secret, subevent=self.subevent)
|
|
except OrderPosition.DoesNotExist:
|
|
response['status'] = 'error'
|
|
response['reason'] = 'unknown_ticket'
|
|
else:
|
|
given_answers = {}
|
|
for q in op.item.questions.filter(ask_during_checkin=True):
|
|
if 'answer_{}'.format(q.pk) in request.POST:
|
|
try:
|
|
given_answers[q] = q.clean_answer(request.POST.get('answer_{}'.format(q.pk)))
|
|
except ValidationError:
|
|
pass
|
|
|
|
try:
|
|
if not self.config.all_items and op.item_id not in [i.pk for i in self.config.items.all()]:
|
|
raise CheckInError('', 'product')
|
|
perform_checkin(
|
|
op=op,
|
|
clist=self.config.list,
|
|
given_answers=given_answers,
|
|
force=force,
|
|
ignore_unpaid=ignore_unpaid,
|
|
nonce=nonce,
|
|
datetime=dt,
|
|
questions_supported=bool(request.POST.get('questions_supported'))
|
|
)
|
|
except RequiredQuestionsError as e:
|
|
response['status'] = 'incomplete'
|
|
response['questions'] = [serialize_question(q) for q in e.questions]
|
|
except CheckInError as e:
|
|
response['status'] = 'error'
|
|
response['reason'] = e.code
|
|
else:
|
|
response['status'] = 'ok'
|
|
|
|
response['data'] = serialize_op(op, redeemed=op.order.status == Order.STATUS_PAID or force,
|
|
clist=self.config.list)
|
|
|
|
return JsonResponse(response)
|
|
|
|
|
|
def serialize_question(q, items=False):
|
|
d = {
|
|
'id': q.pk,
|
|
'type': q.type,
|
|
'question': str(q.question),
|
|
'required': q.required,
|
|
'position': q.position,
|
|
'options': [
|
|
{
|
|
'id': o.pk,
|
|
'answer': str(o.answer)
|
|
} for o in q.options.all()
|
|
] if q.type in ('C', 'M') else []
|
|
}
|
|
if items:
|
|
d['items'] = [i.pk for i in q.items.all()]
|
|
return d
|
|
|
|
|
|
def serialize_op(op, redeemed, clist):
|
|
name = op.attendee_name
|
|
if not name and op.addon_to:
|
|
name = op.addon_to.attendee_name
|
|
if not name:
|
|
try:
|
|
name = op.order.invoice_address.name
|
|
except:
|
|
pass
|
|
checkin_allowed = (
|
|
op.order.status == Order.STATUS_PAID
|
|
or (
|
|
op.order.status == Order.STATUS_PENDING
|
|
and clist.include_pending
|
|
)
|
|
)
|
|
return {
|
|
'secret': op.secret,
|
|
'order': op.order.code,
|
|
'item': str(op.item),
|
|
'item_id': op.item_id,
|
|
'variation': str(op.variation) if op.variation else None,
|
|
'variation_id': op.variation_id,
|
|
'attendee_name': name,
|
|
'attention': op.item.checkin_attention or op.order.checkin_attention,
|
|
'redeemed': redeemed,
|
|
'paid': op.order.status == Order.STATUS_PAID,
|
|
'checkin_allowed': checkin_allowed,
|
|
'addons_text': ", ".join([
|
|
'{} - {}'.format(p.item, p.variation) if p.variation else str(p.item)
|
|
for p in op.addons.all()
|
|
])
|
|
}
|
|
|
|
|
|
class ApiSearchView(ApiView):
|
|
def get(self, request, **kwargs):
|
|
query = request.GET.get('query', '!INVALID!')
|
|
response = {
|
|
'version': API_VERSION
|
|
}
|
|
|
|
if len(query) >= 4:
|
|
cqs = Checkin.objects.filter(
|
|
position_id=OuterRef('pk'),
|
|
list_id=self.config.list.pk
|
|
).order_by().values('position_id').annotate(
|
|
m=Max('datetime')
|
|
).values('m')
|
|
|
|
qs = OrderPosition.objects.filter(
|
|
order__event=self.event,
|
|
subevent=self.config.list.subevent
|
|
).annotate(
|
|
last_checked_in=Subquery(cqs)
|
|
).select_related('item', 'variation', 'order', 'order__invoice_address', 'addon_to').prefetch_related(
|
|
'addons', 'addons__item', 'addons__variation'
|
|
)
|
|
|
|
if not self.config.list.all_products:
|
|
qs = qs.filter(item__in=self.config.list.limit_products.values_list('id', flat=True))
|
|
|
|
if not self.config.all_items:
|
|
qs = qs.filter(item__in=self.config.items.all())
|
|
|
|
if not self.config.allow_search:
|
|
ops = qs.filter(
|
|
Q(secret__istartswith=query)
|
|
)[:25]
|
|
else:
|
|
ops = qs.filter(
|
|
Q(secret__istartswith=query)
|
|
| Q(attendee_name__icontains=query)
|
|
| Q(addon_to__attendee_name__icontains=query)
|
|
| Q(order__code__istartswith=query)
|
|
| Q(order__invoice_address__name__icontains=query)
|
|
)[:25]
|
|
|
|
response['results'] = [serialize_op(op, bool(op.last_checked_in), self.config.list) for op in ops]
|
|
else:
|
|
response['results'] = []
|
|
|
|
return JsonResponse(response)
|
|
|
|
|
|
class ApiDownloadView(ApiView):
|
|
def get(self, request, **kwargs):
|
|
response = {
|
|
'version': API_VERSION
|
|
}
|
|
|
|
cqs = Checkin.objects.filter(
|
|
position_id=OuterRef('pk'),
|
|
list_id=self.config.list.pk
|
|
).order_by().values('position_id').annotate(
|
|
m=Max('datetime')
|
|
).values('m')
|
|
|
|
qs = OrderPosition.objects.filter(
|
|
order__event=self.event,
|
|
order__status__in=[Order.STATUS_PAID] + ([Order.STATUS_PENDING] if self.config.list.include_pending else
|
|
[]),
|
|
subevent=self.config.list.subevent
|
|
).annotate(
|
|
last_checked_in=Subquery(cqs)
|
|
).select_related('item', 'variation', 'order', 'addon_to').prefetch_related(
|
|
'addons', 'addons__item', 'addons__variation'
|
|
)
|
|
|
|
if not self.config.list.all_products:
|
|
qs = qs.filter(item__in=self.config.list.limit_products.values_list('id', flat=True))
|
|
|
|
if not self.config.all_items:
|
|
qs = qs.filter(item__in=self.config.items.all())
|
|
|
|
response['results'] = [serialize_op(op, bool(op.last_checked_in), self.config.list) for op in qs]
|
|
|
|
questions = self.event.questions.filter(ask_during_checkin=True).prefetch_related('items', 'options')
|
|
response['questions'] = [serialize_question(q, items=True) for q in questions]
|
|
return JsonResponse(response)
|
|
|
|
|
|
class ApiStatusView(ApiView):
|
|
def get(self, request, **kwargs):
|
|
|
|
cqs = Checkin.objects.filter(
|
|
position__order__event=self.event, position__subevent=self.subevent,
|
|
position__order__status__in=[Order.STATUS_PAID] + ([Order.STATUS_PENDING] if
|
|
self.config.list.include_pending else []),
|
|
list=self.config.list
|
|
)
|
|
pqs = OrderPosition.objects.filter(
|
|
order__event=self.event,
|
|
order__status__in=[Order.STATUS_PAID] + ([Order.STATUS_PENDING] if self.config.list.include_pending else
|
|
[]),
|
|
subevent=self.subevent,
|
|
)
|
|
if not self.config.list.all_products:
|
|
pqs = pqs.filter(item__in=self.config.list.limit_products.values_list('id', flat=True))
|
|
|
|
ev = self.subevent or self.event
|
|
response = {
|
|
'version': API_VERSION,
|
|
'event': {
|
|
'name': str(ev.name),
|
|
'list': self.config.list.name,
|
|
'slug': self.event.slug,
|
|
'organizer': {
|
|
'name': str(self.event.organizer),
|
|
'slug': self.event.organizer.slug
|
|
},
|
|
'subevent': self.subevent.pk if self.subevent else str(self.event),
|
|
'date_from': ev.date_from,
|
|
'date_to': ev.date_to,
|
|
'timezone': self.event.settings.timezone,
|
|
'url': event_absolute_uri(self.event, 'presale:event.index')
|
|
},
|
|
'checkins': cqs.count(),
|
|
'total': pqs.count()
|
|
}
|
|
|
|
op_by_item = {
|
|
p['item']: p['cnt']
|
|
for p in pqs.order_by().values('item').annotate(cnt=Count('id'))
|
|
}
|
|
op_by_variation = {
|
|
p['variation']: p['cnt']
|
|
for p in pqs.order_by().values('variation').annotate(cnt=Count('id'))
|
|
}
|
|
c_by_item = {
|
|
p['position__item']: p['cnt']
|
|
for p in cqs.order_by().values('position__item').annotate(cnt=Count('id'))
|
|
}
|
|
c_by_variation = {
|
|
p['position__variation']: p['cnt']
|
|
for p in cqs.order_by().values('position__variation').annotate(cnt=Count('id'))
|
|
}
|
|
|
|
response['items'] = []
|
|
for item in self.event.items.order_by('pk').prefetch_related('variations'):
|
|
i = {
|
|
'id': item.pk,
|
|
'name': str(item),
|
|
'admission': item.admission,
|
|
'checkins': c_by_item.get(item.pk, 0),
|
|
'total': op_by_item.get(item.pk, 0),
|
|
'variations': []
|
|
}
|
|
for var in item.variations.all():
|
|
i['variations'].append({
|
|
'id': var.pk,
|
|
'name': str(var),
|
|
'checkins': c_by_variation.get(var.pk, 0),
|
|
'total': op_by_variation.get(var.pk, 0),
|
|
})
|
|
response['items'].append(i)
|
|
|
|
return JsonResponse(response)
|