Add sub-events and relative date settings (#503)

* Data model

* little crud

* SubEventItemForm etc

* Drop SubEventItem.active, quota editor

* Fix failing tests

* First frontend stuff

* Addons form stuff

* Quota calculation

* net price display on EventIndex

* Add tests, solve some bugs

* Correct quota selection in more places, consolidate pricing logic

* Fix failing quota tests

* Fix TypeError

* Add tests for checkout

* Fixed a bug in QuotaForm

* Prevent immutable cart if a quota was removed from an item

* Add tests for pricing

* Handle waiting list

* Filter in check-in list

* Fixed import lost in rebase

* Fix waiting list widget

* Voucher management

* Voucher redemption

* Fix broken tests

* Add subevents to OrderChangeManager

* Create a subevent during event creation

* Fix bulk voucher creation

* Introduce subevent.active

* Copy from for subevents

* Show active in list

* ICal download for subevents

* Check start and end of presale

* Failing tests / show cart logic

* Test

* Rebase migrations

* REST API integration of sub-events

* Integrate quota calculation into the traditional quota form

* Make subevent argument to add_position optional

* Log-display foo

* pretixdroid and subevents

* Filter by subevent

* Add more tests

* Some mor tests

* Rebase fixes

* More tests

* Relative dates

* Restrict selection in relative datetime widgets

* Filter subevent list

* Re-label has_subevents

* Rebase fixes, subevents in calendar view

* Performance and caching issues

* Refactor calendar templates

* Permission tests

* Calendar fixes and month selection

* subevent selection

* Rename subevents to dates

* Add tests for calendar views
This commit is contained in:
Raphael Michel
2017-07-11 13:56:00 +02:00
committed by GitHub
parent 554800c06f
commit 8123effa65
141 changed files with 5920 additions and 1012 deletions

View File

@@ -30,7 +30,7 @@ class CartMixin:
cartpos = queryset.order_by(
'item', 'variation'
).select_related(
'item', 'variation', 'addon_to'
'item', 'variation', 'addon_to', 'subevent', 'subevent__event', 'subevent__event__organizer'
).prefetch_related(
*prefetch
)
@@ -73,11 +73,14 @@ class CartMixin:
)
addon_penalty = 1 if pos.addon_to else 0
if downloads or pos.pk in has_addons or pos.addon_to:
return i, addon_penalty, pos.pk, 0, 0, 0, 0,
return i, addon_penalty, pos.pk, 0, 0, 0, 0, (pos.subevent_id or 0)
if answers and (has_attendee_data or pos.item.questions.all()):
return i, addon_penalty, pos.pk, 0, 0, 0, 0,
return i, addon_penalty, pos.pk, 0, 0, 0, 0, (pos.subevent_id or 0)
return 0, addon_penalty, 0, pos.item_id, pos.variation_id, pos.price, (pos.voucher_id or 0)
return (
0, addon_penalty, 0, pos.item_id, pos.variation_id, pos.price, (pos.voucher_id or 0),
(pos.subevent_id or 0)
)
positions = []
for k, g in groupby(sorted(lcp, key=keyfunc), key=keyfunc):
@@ -144,7 +147,7 @@ def get_cart(request):
).order_by(
'item', 'variation'
).select_related(
'item', 'variation'
'item', 'variation', 'subevent', 'subevent__event', 'subevent__event__organizer'
).prefetch_related(
'item__questions', 'answers'
)

View File

@@ -2,7 +2,7 @@ import mimetypes
import os
from django.contrib import messages
from django.db.models import Count, Q
from django.db.models import Count, Prefetch, Q
from django.http import FileResponse, Http404, JsonResponse
from django.shortcuts import get_object_or_404, redirect
from django.utils import translation
@@ -11,7 +11,9 @@ from django.utils.translation import ugettext as _
from django.views.generic import TemplateView, View
from pretix.base.decimal import round_decimal
from pretix.base.models import CartPosition, QuestionAnswer, Quota, Voucher
from pretix.base.models import (
CartPosition, ItemVariation, QuestionAnswer, Quota, SubEvent, Voucher,
)
from pretix.base.services.cart import (
CartError, add_items_to_cart, clear_cart, remove_cart_position,
)
@@ -60,7 +62,8 @@ class CartActionMixin:
'variation': None,
'count': amount,
'price': price,
'voucher': voucher
'voucher': voucher,
'subevent': self.request.POST.get("subevent")
}
except ValueError:
raise CartError(_('Please enter numbers only.'))
@@ -71,7 +74,8 @@ class CartActionMixin:
'variation': int(parts[2]),
'count': amount,
'price': price,
'voucher': voucher
'voucher': voucher,
'subevent': self.request.POST.get("subevent")
}
except ValueError:
raise CartError(_('Please enter numbers only.'))
@@ -188,10 +192,29 @@ class RedeemView(EventViewMixin, TemplateView):
items = items.filter(vouchq).select_related(
'category', # for re-grouping
).prefetch_related(
'quotas', 'variations__quotas', 'quotas__event' # for .availability()
).annotate(quotac=Count('quotas')).filter(
Prefetch('quotas',
to_attr='_subevent_quotas',
queryset=self.request.event.quotas.filter(subevent=self.subevent)),
Prefetch('variations', to_attr='avail_variations',
queryset=ItemVariation.objects.filter(active=True, quotas__isnull=False).prefetch_related(
Prefetch('quotas',
to_attr='_subevent_quotas',
queryset=self.request.event.quotas.filter(subevent=self.subevent))
).distinct()),
).annotate(
quotac=Count('quotas'),
has_variations=Count('variations')
).filter(
quotac__gt=0
).distinct().order_by('category__position', 'category_id', 'position', 'name')
quota_cache = {}
if self.subevent:
item_price_override = self.subevent.item_price_overrides
var_price_override = self.subevent.var_price_overrides
else:
item_price_override = {}
var_price_override = {}
for item in items:
item.available_variations = list(item.variations.filter(active=True, quotas__isnull=False).distinct())
@@ -202,34 +225,49 @@ class RedeemView(EventViewMixin, TemplateView):
item.has_variations = item.variations.exists()
if not item.has_variations:
item._remove = not bool(item._subevent_quotas)
if self.voucher.allow_ignore_quota or self.voucher.block_quota:
item.cached_availability = (Quota.AVAILABILITY_OK, 1)
else:
item.cached_availability = item.check_quotas()
item.price = self.voucher.calculate_price(item.default_price)
item.cached_availability = item.check_quotas(subevent=self.subevent, _cache=quota_cache)
item.price = item_price_override.get(item.pk, item.default_price)
item.price = self.voucher.calculate_price(item.price)
if self.request.event.settings.display_net_prices:
item.price -= round_decimal(item.price * (1 - 100 / (100 + item.tax_rate)))
else:
for var in item.available_variations:
item._remove = False
for var in item.avail_variations:
if self.voucher.allow_ignore_quota or self.voucher.block_quota:
var.cached_availability = (Quota.AVAILABILITY_OK, 1)
else:
var.cached_availability = list(var.check_quotas())
var.display_price = self.voucher.calculate_price(var.price)
var.cached_availability = list(var.check_quotas(subevent=self.subevent, _cache=quota_cache))
var.display_price = var_price_override.get(var.pk, var.price)
var.display_price = self.voucher.calculate_price(var.display_price)
if self.request.event.settings.display_net_prices:
var.display_price -= round_decimal(var.display_price * (1 - 100 / (100 + item.tax_rate)))
item.available_variations = [
v for v in item.avail_variations if v._subevent_quotas
]
if self.voucher.variation_id:
item.available_variations = [v for v in item.available_variations
if v.pk == self.voucher.variation_id]
if len(item.available_variations) > 0:
item.min_price = min([v.display_price for v in item.available_variations])
item.max_price = max([v.display_price for v in item.available_variations])
item.min_price = min([v.display_price for v in item.avail_variations])
item.max_price = max([v.display_price for v in item.avail_variations])
items = [item for item in items if len(item.available_variations) > 0 or not item.has_variations]
items = [item for item in items
if (len(item.available_variations) > 0 or not item.has_variations) and not item._remove]
context['options'] = sum([(len(item.available_variations) if item.has_variations else 1)
for item in items])
# Regroup those by category
context['items_by_category'] = item_group_by_category(items)
context['subevent'] = self.subevent
return context
def dispatch(self, request, *args, **kwargs):
@@ -264,6 +302,17 @@ class RedeemView(EventViewMixin, TemplateView):
if request.event.presale_end and now() > request.event.presale_end:
err = error_messages['ended']
self.subevent = None
if request.event.has_subevents:
if 'subevent' in request.GET:
self.subevent = get_object_or_404(SubEvent, event=request.event, pk=request.GET.get('subevent'),
active=True)
if self.voucher.subevent:
self.subevent = self.voucher.subevent
else:
pass
if err:
messages.error(request, _(err))
return redirect(eventreverse(request.event, 'presale:event.index'))

View File

@@ -1,5 +1,7 @@
import calendar
import sys
from datetime import datetime
from collections import defaultdict
from datetime import date, datetime, timedelta
from importlib import import_module
import pytz
@@ -8,19 +10,24 @@ from django.conf import settings
from django.core.exceptions import PermissionDenied
from django.db.models import Count, Prefetch, Q
from django.http import Http404, HttpResponse
from django.shortcuts import redirect
from django.shortcuts import get_object_or_404, redirect
from django.utils.decorators import method_decorator
from django.utils.formats import date_format
from django.utils.functional import cached_property
from django.utils.timezone import now
from django.utils.translation import ugettext_lazy as _
from django.utils.translation import pgettext_lazy, ugettext_lazy as _
from django.views import View
from django.views.decorators.csrf import csrf_exempt
from django.views.generic import TemplateView
from pytz import timezone
from pretix.base.decimal import round_decimal
from pretix.base.models import ItemVariation
from pretix.base.models.event import SubEvent
from pretix.multidomain.urlreverse import eventreverse
from pretix.presale.views.organizer import (
add_subevents_for_days, weeks_for_template,
)
from . import CartMixin, EventViewMixin, get_cart
@@ -41,7 +48,7 @@ def item_group_by_category(items):
)
def get_grouped_items(event):
def get_grouped_items(event, subevent=None):
items = event.items.all().filter(
Q(active=True)
& Q(Q(available_from__isnull=True) | Q(available_from__lte=now()))
@@ -51,11 +58,15 @@ def get_grouped_items(event):
).select_related(
'category', # for re-grouping
).prefetch_related(
'variations__quotas', # for .availability()
Prefetch('quotas',
queryset=event.quotas.all()),
to_attr='_subevent_quotas',
queryset=event.quotas.filter(subevent=subevent)),
Prefetch('variations', to_attr='available_variations',
queryset=ItemVariation.objects.filter(active=True, quotas__isnull=False).distinct()),
queryset=ItemVariation.objects.filter(active=True, quotas__isnull=False).prefetch_related(
Prefetch('quotas',
to_attr='_subevent_quotas',
queryset=event.quotas.filter(subevent=subevent))
).distinct()),
).annotate(
quotac=Count('quotas'),
has_variations=Count('variations')
@@ -64,54 +75,156 @@ def get_grouped_items(event):
).order_by('category__position', 'category_id', 'position', 'name')
display_add_to_cart = False
quota_cache = {}
if subevent:
item_price_override = subevent.item_price_overrides
var_price_override = subevent.var_price_overrides
else:
item_price_override = {}
var_price_override = {}
for item in items:
max_per_order = item.max_per_order or int(event.settings.max_items_per_order)
if not item.has_variations:
item.cached_availability = list(item.check_quotas(_cache=quota_cache))
item._remove = not bool(item._subevent_quotas)
item.cached_availability = list(item.check_quotas(subevent=subevent, _cache=quota_cache))
item.order_max = min(item.cached_availability[1]
if item.cached_availability[1] is not None else sys.maxsize,
max_per_order)
item.price = item.default_price
item.display_price = item.default_price_net if event.settings.display_net_prices else item.price
if event.settings.display_net_prices:
if item_price_override.get(item.pk):
_p = item_price_override.get(item.pk)
tax_value = round_decimal(_p * (1 - 100 / (100 + item.tax_rate)))
item.display_price = _p - tax_value
else:
item.display_price = item.default_price_net
else:
item.display_price = item_price_override.get(item.pk, item.price)
display_add_to_cart = display_add_to_cart or item.order_max > 0
else:
for var in item.available_variations:
var.cached_availability = list(var.check_quotas(_cache=quota_cache))
var.cached_availability = list(var.check_quotas(subevent=subevent, _cache=quota_cache))
var.order_max = min(var.cached_availability[1]
if var.cached_availability[1] is not None else sys.maxsize,
max_per_order)
var.display_price = var.net_price if event.settings.display_net_prices else var.price
if event.settings.display_net_prices:
if var_price_override.get(var.pk):
_p = var_price_override.get(var.pk)
tax_value = round_decimal(_p * (1 - 100 / (100 + item.tax_rate)))
var.display_price = _p - tax_value
else:
var.display_price = var.net_price
else:
var.display_price = var_price_override.get(var.pk, var.price)
display_add_to_cart = display_add_to_cart or var.order_max > 0
item.available_variations = [
v for v in item.available_variations if v._subevent_quotas
]
if len(item.available_variations) > 0:
item.min_price = min([v.display_price for v in item.available_variations])
item.max_price = max([v.display_price for v in item.available_variations])
item._remove = not bool(item.available_variations)
items = [item for item in items if len(item.available_variations) > 0 or not item.has_variations]
items = [item for item in items
if (len(item.available_variations) > 0 or not item.has_variations) and not item._remove]
return items, display_add_to_cart
class EventIndex(EventViewMixin, CartMixin, TemplateView):
template_name = "pretixpresale/event/index.html"
def get(self, request, *args, **kwargs):
self.subevent = None
if request.event.has_subevents:
if 'subevent' in kwargs:
self.subevent = request.event.subevents.filter(pk=kwargs['subevent'], active=True).first()
if not self.subevent:
raise Http404()
return super().get(request, *args, **kwargs)
else:
return super().get(request, *args, **kwargs)
else:
if 'subevent' in kwargs:
return redirect(eventreverse(request.event, 'presale:event.index'))
else:
return super().get(request, *args, **kwargs)
def _set_month_year(self):
tz = pytz.timezone(self.request.event.settings.timezone)
if self.subevent:
self.year = self.subevent.date_from.astimezone(tz).year
self.month = self.subevent.date_from.astimezone(tz).month
elif 'year' in self.request.GET and 'month' in self.request.GET:
try:
self.year = int(self.request.GET.get('year'))
self.month = int(self.request.GET.get('month'))
except ValueError:
self.year = now().year
self.month = now().month
else:
next_sev = self.request.event.subevents.filter(
active=True,
date_from__gte=now()
).select_related('event').order_by('date_from').first()
if next_sev:
datetime_from = next_sev.date_from
self.year = datetime_from.astimezone(tz).year
self.month = datetime_from.astimezone(tz).month
else:
self.year = now().year
self.month = now().month
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
# Fetch all items
items, display_add_to_cart = get_grouped_items(self.request.event)
if not self.request.event.has_subevents or self.subevent:
# Fetch all items
items, display_add_to_cart = get_grouped_items(self.request.event, self.subevent)
# Regroup those by category
context['items_by_category'] = item_group_by_category(items)
context['display_add_to_cart'] = display_add_to_cart
# Regroup those by category
context['items_by_category'] = item_group_by_category(items)
context['display_add_to_cart'] = display_add_to_cart
context['subevent'] = self.subevent
context['cart'] = self.get_cart()
context['has_addon_choices'] = get_cart(self.request).filter(item__addons__isnull=False).exists()
vouchers_exist = self.request.event.get_cache().get('vouchers_exist')
if vouchers_exist is None:
vouchers_exist = self.request.event.vouchers.exists()
self.request.event.get_cache().set('vouchers_exist', vouchers_exist)
context['vouchers_exist'] = vouchers_exist
context['cart'] = self.get_cart()
context['has_addon_choices'] = get_cart(self.request).filter(item__addons__isnull=False).exists()
context['ev'] = self.subevent or self.request.event
context['frontpage_text'] = str(self.request.event.settings.frontpage_text)
if self.request.event.settings.event_list_type == "calendar":
self._set_month_year()
tz = pytz.timezone(self.request.event.settings.timezone)
_, ndays = calendar.monthrange(self.year, self.month)
before = datetime(self.year, self.month, 1, 0, 0, 0, tzinfo=tz) - timedelta(days=1)
after = datetime(self.year, self.month, ndays, 0, 0, 0, tzinfo=tz) + timedelta(days=1)
context['date'] = date(self.year, self.month, 1)
context['before'] = before
context['after'] = after
ebd = defaultdict(list)
add_subevents_for_days(self.request.event.subevents.all(), before, after, ebd, set(), self.request.event)
context['weeks'] = weeks_for_template(ebd, self.year, self.month)
context['months'] = [date(self.year, i + 1, 1) for i in range(12)]
context['years'] = range(now().year - 2, now().year + 3)
context['show_cart'] = (
context['cart']['positions'] and (
self.request.event.has_subevents or self.request.event.presale_is_running
)
)
return context
@@ -125,39 +238,52 @@ class EventIcalDownload(EventViewMixin, View):
if not self.request.event:
raise Http404(_('Unknown event code or not authorized to access this event.'))
subevent = None
if request.event.has_subevents:
if 'subevent' in kwargs:
subevent = get_object_or_404(SubEvent, event=request.event, pk=kwargs['subevent'], active=True)
else:
raise Http404(pgettext_lazy('subevent', 'No date selected.'))
else:
if 'subevent' in kwargs:
raise Http404(pgettext_lazy('subevent', 'Unknown date selected.'))
event = self.request.event
ev = subevent or event
creation_time = datetime.now(pytz.utc)
cal = vobject.iCalendar()
cal.add('prodid').value = '-//pretix//{}//'.format(settings.PRETIX_INSTANCE_NAME)
vevent = cal.add('vevent')
vevent.add('summary').value = str(event.name)
vevent.add('summary').value = str(ev.name)
vevent.add('dtstamp').value = creation_time
vevent.add('location').value = str(event.location)
vevent.add('location').value = str(ev.location)
vevent.add('organizer').value = event.organizer.name
vevent.add('uid').value = '{}-{}-{}'.format(
event.organizer.slug, event.slug, creation_time.strftime('%Y%m%d%H%M%S%f')
vevent.add('uid').value = '{}-{}-{}-{}'.format(
event.organizer.slug, event.slug,
subevent.pk if subevent else '0',
creation_time.strftime('%Y%m%d%H%M%S%f')
)
if event.settings.show_times:
vevent.add('dtstart').value = event.date_from.astimezone(self.event_timezone)
vevent.add('dtstart').value = ev.date_from.astimezone(self.event_timezone)
else:
vevent.add('dtstart').value = event.date_from.astimezone(self.event_timezone).date()
vevent.add('dtstart').value = ev.date_from.astimezone(self.event_timezone).date()
if event.settings.show_date_to:
if event.settings.show_date_to and ev.date_to:
if event.settings.show_times:
vevent.add('dtend').value = event.date_to.astimezone(self.event_timezone)
vevent.add('dtend').value = ev.date_to.astimezone(self.event_timezone)
else:
vevent.add('dtend').value = event.date_to.astimezone(self.event_timezone).date()
vevent.add('dtend').value = ev.date_to.astimezone(self.event_timezone).date()
if event.date_admission:
vevent.add('description').value = str(_('Admission: {datetime}')).format(
datetime=date_format(event.date_admission.astimezone(self.event_timezone), 'SHORT_DATETIME_FORMAT')
datetime=date_format(ev.date_admission.astimezone(self.event_timezone), 'SHORT_DATETIME_FORMAT')
)
resp = HttpResponse(cal.serialize(), content_type='text/calendar')
resp['Content-Disposition'] = 'attachment; filename="{}-{}.ics"'.format(
event.organizer.slug, event.slug
resp['Content-Disposition'] = 'attachment; filename="{}-{}-{}.ics"'.format(
event.organizer.slug, event.slug, subevent.pk if subevent else '0',
)
return resp

View File

@@ -82,11 +82,14 @@ class OrderDetails(EventViewMixin, OrderDetailMixin, CartMixin, TemplateView):
def get_context_data(self, **kwargs):
ctx = super().get_context_data(**kwargs)
ctx['order'] = self.order
if self.request.event.settings.ticket_download_date:
ctx['ticket_download_date'] = self.order.ticket_download_date
ctx['can_download'] = (
self.request.event.settings.ticket_download
and (
self.request.event.settings.ticket_download_date is None
or now() > self.request.event.settings.ticket_download_date
or now() > self.order.ticket_download_date
) and self.order.status == Order.STATUS_PAID
)
ctx['download_buttons'] = self.download_buttons
@@ -138,10 +141,10 @@ class OrderPaymentStart(EventViewMixin, OrderDetailMixin, TemplateView):
messages.error(request, _('The payment for this order cannot be continued.'))
return redirect(self.get_order_url())
if self.request.event.settings.get('payment_term_last'):
if now() > self.request.event.payment_term_last:
messages.error(request, _('The payment is too late to be accepted.'))
return redirect(self.get_order_url())
term_last = self.order.payment_term_last
if term_last and now() > term_last:
messages.error(request, _('The payment is too late to be accepted.'))
return redirect(self.get_order_url())
return super().dispatch(request, *args, **kwargs)
def post(self, request, *args, **kwargs):
@@ -233,10 +236,10 @@ class OrderPaymentComplete(EventViewMixin, OrderDetailMixin, View):
messages.error(request, _('The payment information you entered was incomplete.'))
return redirect(self.get_payment_url())
if self.request.event.settings.get('payment_term_last'):
if now() > self.request.event.payment_term_last:
messages.error(request, _('The payment is too late to be accepted.'))
return redirect(self.get_order_url())
term_last = self.order.payment_term_last
if term_last and now() > term_last:
messages.error(request, _('The payment is too late to be accepted.'))
return redirect(self.get_order_url())
return super().dispatch(request, *args, **kwargs)
@@ -270,10 +273,10 @@ class OrderPayChangeMethod(EventViewMixin, OrderDetailMixin, TemplateView):
messages.error(request, _('The payment method for this order cannot be changed.'))
return redirect(self.get_order_url())
if self.request.event.settings.get('payment_term_last'):
if now() > self.request.event.payment_term_last:
messages.error(request, _('The payment is too late to be accepted.'))
return redirect(self.get_order_url())
term_last = self.order.payment_term_last
if term_last and now() > term_last:
messages.error(request, _('The payment is too late to be accepted.'))
return redirect(self.get_order_url())
return super().dispatch(request, *args, **kwargs)
@@ -551,7 +554,7 @@ class OrderDownload(EventViewMixin, OrderDetailMixin, View):
return self.error(_('Order is not paid.'))
if (not self.request.event.settings.ticket_download
or (self.request.event.settings.ticket_download_date is not None
and now() < self.request.event.settings.ticket_download_date)):
and now() < self.order.ticket_download_date)):
return self.error(_('Ticket download is not (yet) enabled.'))
if 'position' in kwargs and (self.order_position.addon_to and not self.request.event.settings.ticket_download_addons):
return self.error(_('Ticket download is not enabled for add-on products.'))

View File

@@ -8,7 +8,7 @@ from django.utils.timezone import now
from django.views.generic import ListView, TemplateView
from pytz import UTC
from pretix.base.models import Event
from pretix.base.models import Event, SubEvent
from pretix.multidomain.urlreverse import eventreverse
from pretix.presale.views import OrganizerViewMixin
@@ -40,6 +40,104 @@ class OrganizerIndex(OrganizerViewMixin, ListView):
).order_by(order)
def add_events_for_days(organizer, before, after, ebd, timezones):
qs = organizer.events.filter(is_public=True, live=True, has_subevents=False).filter(
Q(Q(date_to__gte=before) & Q(date_from__lte=after)) |
Q(Q(date_from__lte=after) & Q(date_to__gte=before)) |
Q(Q(date_to__isnull=True) & Q(date_from__gte=before) & Q(date_from__lte=after))
).order_by(
'date_from'
).prefetch_related(
'_settings_objects', 'organizer___settings_objects'
)
for event in qs:
timezones.add(event.settings.timezones)
tz = pytz.timezone(event.settings.timezone)
datetime_from = event.date_from.astimezone(tz)
date_from = datetime_from.date()
if event.settings.show_date_to and event.date_to:
date_to = event.date_to.astimezone(tz).date()
d = max(date_from, before.date())
while d <= date_to and d <= after.date():
first = d == date_from
ebd[d].append({
'event': event,
'continued': not first,
'time': datetime_from.time().replace(tzinfo=None) if first and event.settings.show_times else None,
'url': eventreverse(event, 'presale:event.index'),
'timezone': event.settings.timezone,
})
d += timedelta(days=1)
else:
ebd[date_from].append({
'event': event,
'continued': False,
'time': datetime_from.time().replace(tzinfo=None) if event.settings.show_times else None,
'url': eventreverse(event, 'presale:event.index'),
'timezone': event.settings.timezone,
})
def add_subevents_for_days(qs, before, after, ebd, timezones, event=None):
qs = qs.filter(active=True).filter(
Q(Q(date_to__gte=before) & Q(date_from__lte=after)) |
Q(Q(date_from__lte=after) & Q(date_to__gte=before)) |
Q(Q(date_to__isnull=True) & Q(date_from__gte=before) & Q(date_from__lte=after))
).order_by(
'date_from'
)
for se in qs:
settings = event.settings if event else se.event.settings
timezones.add(settings.timezones)
tz = pytz.timezone(settings.timezone)
datetime_from = se.date_from.astimezone(tz)
date_from = datetime_from.date()
if se.event.settings.show_date_to and se.date_to:
date_to = se.date_to.astimezone(tz).date()
d = max(date_from, before.date())
while d <= date_to and d <= after.date():
first = d == date_from
ebd[d].append({
'continued': not first,
'timezone': settings.timezone,
'time': datetime_from.time().replace(tzinfo=None) if first and settings.show_times else None,
'event': se,
'url': eventreverse(se.event, 'presale:event.index', kwargs={
'subevent': se.pk
}),
})
d += timedelta(days=1)
else:
ebd[date_from].append({
'event': se,
'continued': False,
'time': datetime_from.time().replace(tzinfo=None) if se.event.settings.show_times else None,
'url': eventreverse(se.event, 'presale:event.index', kwargs={
'subevent': se.pk
}),
'timezone': se.event.settings.timezone,
})
def weeks_for_template(ebd, year, month):
calendar.setfirstweekday(0) # TODO: Configurable
return [
[
{
'day': day,
'date': date(year, month, day),
'events': ebd.get(date(year, month, day))
}
if day > 0
else None
for day in week
]
for week in calendar.monthcalendar(year, month)
]
class CalendarView(OrganizerViewMixin, TemplateView):
template_name = 'pretixpresale/organizers/calendar.html'
@@ -47,12 +145,42 @@ class CalendarView(OrganizerViewMixin, TemplateView):
if 'year' in kwargs and 'month' in kwargs:
self.year = int(kwargs.get('year'))
self.month = int(kwargs.get('month'))
elif 'year' in request.GET and 'month' in request.GET:
try:
self.year = int(request.GET.get('year'))
self.month = int(request.GET.get('month'))
except ValueError:
self.year = now().year
self.month = now().month
else:
next_ev = Event.objects.filter(live=True, is_public=True, date_from__gte=now()).order_by('date_from').first()
tz = pytz.timezone(next_ev.settings.timezone)
datetime_from = next_ev.date_from.astimezone(tz)
self.year = datetime_from.year
self.month = datetime_from.month
next_ev = Event.objects.filter(
live=True,
is_public=True,
date_from__gte=now(),
has_subevents=False
).order_by('date_from').first()
next_sev = SubEvent.objects.filter(
event__organizer=self.request.organizer,
event__is_public=True,
event__live=True,
active=True,
date_from__gte=now()
).select_related('event').order_by('date_from').first()
datetime_from = None
if (next_ev and next_sev and next_sev.date_from < next_ev.date_from) or (next_sev and not next_ev):
datetime_from = next_sev.date_from
next_ev = next_sev.event
elif next_ev:
datetime_from = next_ev.date_from
if datetime_from:
tz = pytz.timezone(next_ev.settings.timezone)
self.year = datetime_from.astimezone(tz).year
self.month = datetime_from.astimezone(tz).month
else:
self.year = now().year
self.month = now().month
return super().get(request, *args, **kwargs)
def get_context_data(self, **kwargs):
@@ -65,68 +193,25 @@ class CalendarView(OrganizerViewMixin, TemplateView):
ctx['date'] = date(self.year, self.month, 1)
ctx['before'] = before
ctx['after'] = after
ebd = self._events_by_day()
ebd = self._events_by_day(before, after)
calendar.setfirstweekday(0) # TODO: Configurable
ctx['multiple_timezones'] = self._multiple_timezones
ctx['weeks'] = [
[
{
'day': day,
'date': date(self.year, self.month, day),
'events': ebd[date(self.year, self.month, day)]
}
if day > 0
else None
for day in week
]
for week in calendar.monthcalendar(self.year, self.month)
]
ctx['weeks'] = weeks_for_template(ebd, self.year, self.month)
ctx['months'] = [date(self.year, i + 1, 1) for i in range(12)]
ctx['years'] = range(now().year - 2, now().year + 3)
return ctx
def _events_by_day(self):
_, ndays = calendar.monthrange(self.year, self.month)
before = datetime(self.year, self.month, 1, 0, 0, 0, tzinfo=UTC) - timedelta(days=1)
after = datetime(self.year, self.month, ndays, 0, 0, 0, tzinfo=UTC) + timedelta(days=1)
def _events_by_day(self, before, after):
ebd = defaultdict(list)
qs = self.request.organizer.events.filter(is_public=True, live=True).filter(
Q(Q(date_to__gte=before) & Q(date_from__lte=after)) |
Q(Q(date_from__lte=after) & Q(date_to__gte=before)) |
Q(Q(date_to__isnull=True) & Q(date_from__gte=before) & Q(date_from__lte=after))
).order_by(
'date_from'
).prefetch_related(
'_settings_objects', 'organizer___settings_objects'
)
timezones = set()
for event in qs:
timezones.add(event.settings.timezones)
tz = pytz.timezone(event.settings.timezone)
datetime_from = event.date_from.astimezone(tz)
date_from = datetime_from.date()
if event.settings.show_date_to and event.date_to:
date_to = event.date_to.astimezone(tz).date()
d = date_from
while d <= date_to:
first = d == date_from
ebd[d].append({
'event': event,
'continued': not first,
'time': datetime_from.time().replace(tzinfo=None) if first and event.settings.show_times else None,
'url': eventreverse(event, 'presale:event.index'),
'timezone': event.settings.timezone,
})
d += timedelta(days=1)
else:
ebd[date_from].append({
'event': event,
'continued': False,
'time': datetime_from.time().replace(tzinfo=None) if event.settings.show_times else None,
'url': eventreverse(event, 'presale:event.index'),
'timezone': event.settings.timezone,
})
add_events_for_days(self.request.organizer, before, after, ebd, timezones)
add_subevents_for_days(SubEvent.objects.filter(
event__organizer=self.request.organizer,
event__is_public=True,
event__live=True,
).prefetch_related(
'event___settings_objects', 'event__organizer___settings_objects'
), before, after, ebd, timezones)
self._multiple_timezones = len(timezones) > 1
return ebd

View File

@@ -1,10 +1,12 @@
from django.contrib import messages
from django.shortcuts import redirect
from django.shortcuts import get_object_or_404, redirect
from django.utils import translation
from django.utils.functional import cached_property
from django.utils.translation import ugettext_lazy as _
from django.utils.translation import pgettext_lazy, ugettext_lazy as _
from django.views.generic import FormView
from pretix.base.models.event import SubEvent
from ...base.models import Item, ItemVariation, WaitingListEntry
from ...multidomain.urlreverse import eventreverse
from ..forms.waitinglist import WaitingListForm
@@ -19,13 +21,15 @@ class WaitingView(FormView):
kwargs['event'] = self.request.event
kwargs['instance'] = WaitingListEntry(
item=self.item_and_variation[0], variation=self.item_and_variation[1],
event=self.request.event, locale=translation.get_language()
event=self.request.event, locale=translation.get_language(),
subevent=self.subevent
)
return kwargs
def get_context_data(self, **kwargs):
ctx = super().get_context_data()
ctx['event'] = self.request.event
ctx['subevent'] = self.subevent
ctx['item'], ctx['variation'] = self.item_and_variation
return ctx
@@ -54,13 +58,22 @@ class WaitingView(FormView):
messages.error(request, _("We could not identify the product you selected."))
return redirect(eventreverse(self.request.event, 'presale:event.index'))
self.subevent = None
if request.event.has_subevents:
if 'subevent' in request.GET:
self.subevent = get_object_or_404(SubEvent, event=request.event, pk=request.GET['subevent'],
active=True)
else:
messages.error(request, pgettext_lazy('subevent', "You need to select a date."))
return redirect(eventreverse(self.request.event, 'presale:event.index'))
return super().dispatch(request, *args, **kwargs)
def form_valid(self, form):
availability = (
self.item_and_variation[1].check_quotas(count_waitinglist=False)
self.item_and_variation[1].check_quotas(count_waitinglist=False, subevent=self.subevent)
if self.item_and_variation[1]
else self.item_and_variation[0].check_quotas(count_waitinglist=False)
else self.item_and_variation[0].check_quotas(count_waitinglist=False, subevent=self.subevent)
)
if availability[0] == 100:
messages.error(self.request, _("You cannot add yourself to the waiting list as this product is currently "