mirror of
https://github.com/pretix/pretix.git
synced 2026-08-10 10:47:00 +00:00
dc1b62fc56
* Vouchers: Allow to bulk-delete larger numbers * [DRAFT] voucher bulk update * untested draft * Minor fixes * some tests and fixes * More tests * Bulk vouchers - refactor (#6353) * Reuse parse_itemvar from VoucherForm * Refactor: Method for _bulk update check * remove unused parameter * Refactor: Deduplicate get_affected_quotas code * Remove unused delete button * Prevent accidental update of *all* vouchers (cf PR #4960) * Make sure we actually edit the selected items * Use dataclass for bulk-edit data, deduplicate quota-blocking logic * Move dataclass to models.py * Fix linter errors * Fix tests * Fix tests --------- Co-authored-by: luelista <weller@rami.io>
692 lines
31 KiB
Python
692 lines
31 KiB
Python
#
|
||
# This file is part of pretix (Community Edition).
|
||
#
|
||
# Copyright (C) 2014-2020 Raphael Michel and contributors
|
||
# Copyright (C) 2020-today pretix GmbH and contributors
|
||
#
|
||
# This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General
|
||
# Public License as published by the Free Software Foundation in version 3 of the License.
|
||
#
|
||
# ADDITIONAL TERMS APPLY: Pursuant to Section 7 of the GNU Affero General Public License, additional terms are
|
||
# applicable granting you additional permissions and placing additional restrictions on your usage of this software.
|
||
# Please refer to the pretix LICENSE file to obtain the full terms applicable to this work. If you did not receive
|
||
# this file, see <https://pretix.eu/about/en/license>.
|
||
#
|
||
# This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied
|
||
# warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
|
||
# details.
|
||
#
|
||
# You should have received a copy of the GNU Affero General Public License along with this program. If not, see
|
||
# <https://www.gnu.org/licenses/>.
|
||
#
|
||
|
||
# This file is based on an earlier version of pretix which was released under the Apache License 2.0. The full text of
|
||
# the Apache License 2.0 can be obtained at <http://www.apache.org/licenses/LICENSE-2.0>.
|
||
#
|
||
# This file may have since been changed and any changes are released under the terms of AGPLv3 as described above. A
|
||
# full history of changes and contributors is available at <https://github.com/pretix/pretix>.
|
||
#
|
||
# This file contains Apache-licensed contributions copyrighted by: Sohalt, Tobias Kunze
|
||
#
|
||
# Unless required by applicable law or agreed to in writing, software distributed under the Apache License 2.0 is
|
||
# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
||
# License for the specific language governing permissions and limitations under the License.
|
||
|
||
import copy
|
||
import csv
|
||
from collections import Counter, namedtuple
|
||
from io import StringIO
|
||
|
||
from django import forms
|
||
from django.core.exceptions import ObjectDoesNotExist, ValidationError
|
||
from django.core.validators import EmailValidator
|
||
from django.db.models import Count, F, Max
|
||
from django.db.models.functions import Upper
|
||
from django.forms.utils import ErrorDict
|
||
from django.urls import reverse
|
||
from django.utils.timezone import now
|
||
from django.utils.translation import gettext_lazy as _, pgettext_lazy
|
||
from django_scopes.forms import SafeModelChoiceField
|
||
|
||
from pretix.base.email import get_available_placeholders
|
||
from pretix.base.forms import (
|
||
I18nModelForm, MarkdownTextarea, PlaceholderValidator,
|
||
)
|
||
from pretix.base.forms.widgets import format_placeholders_help_text
|
||
from pretix.base.i18n import language
|
||
from pretix.base.models import Item, ItemVariation, Quota, SubEvent, Voucher
|
||
from pretix.base.models.vouchers import VoucherBulkData
|
||
from pretix.base.services.locking import lock_objects
|
||
from pretix.base.services.quotas import QuotaAvailability
|
||
from pretix.control.forms import SplitDateTimeField, SplitDateTimePickerWidget
|
||
from pretix.control.forms.widgets import Select2, Select2ItemVarQuota
|
||
from pretix.control.signals import voucher_form_validation
|
||
from pretix.helpers.models import modelcopy
|
||
|
||
|
||
class FakeChoiceField(forms.ChoiceField):
|
||
def valid_value(self, value):
|
||
return True
|
||
|
||
|
||
class VoucherForm(I18nModelForm):
|
||
itemvar = FakeChoiceField(
|
||
label=_("Product"),
|
||
help_text=_(
|
||
"This product is added to the user's cart if the voucher is redeemed. Instead of a specific product, you "
|
||
"can also select a quota. In this case, all products assigned to this quota can be selected."
|
||
),
|
||
required=True
|
||
)
|
||
|
||
class Meta:
|
||
model = Voucher
|
||
localized_fields = '__all__'
|
||
fields = [
|
||
'code', 'valid_until', 'block_quota', 'allow_ignore_quota', 'value', 'tag',
|
||
'comment', 'max_usages', 'min_usages', 'price_mode', 'subevent', 'show_hidden_items', 'all_addons_included',
|
||
'all_bundles_included', 'budget'
|
||
]
|
||
field_classes = {
|
||
'valid_until': SplitDateTimeField,
|
||
'subevent': SafeModelChoiceField,
|
||
}
|
||
widgets = {
|
||
'valid_until': SplitDateTimePickerWidget(),
|
||
}
|
||
|
||
def __init__(self, *args, **kwargs):
|
||
instance = kwargs.get('instance')
|
||
initial = kwargs.get('initial')
|
||
self.initial_instance_data = None
|
||
if instance:
|
||
if instance.pk:
|
||
self.initial_instance_data = modelcopy(instance)
|
||
try:
|
||
if instance.variation:
|
||
initial['itemvar'] = '%d-%d' % (instance.item.pk, instance.variation.pk)
|
||
elif instance.item:
|
||
initial['itemvar'] = str(instance.item.pk)
|
||
elif instance.quota:
|
||
initial['itemvar'] = 'q-%d' % instance.quota.pk
|
||
except Item.DoesNotExist:
|
||
pass
|
||
super().__init__(*args, **kwargs)
|
||
if not self.event and self.instance:
|
||
self.event = self.instance.event
|
||
|
||
self.fields['tag'].widget.attrs['data-typeahead-url'] = reverse('control:event.vouchers.tags.typeahead', kwargs={
|
||
'event': self.event.slug,
|
||
'organizer': self.event.organizer.slug,
|
||
})
|
||
|
||
if self.event.has_subevents:
|
||
self.fields['subevent'].queryset = self.event.subevents.all()
|
||
self.fields['subevent'].widget = Select2(
|
||
attrs={
|
||
'data-model-select2': 'event',
|
||
'data-select2-url': reverse('control:event.subevents.select2', kwargs={
|
||
'event': self.event.slug,
|
||
'organizer': self.event.organizer.slug,
|
||
}),
|
||
}
|
||
)
|
||
self.fields['subevent'].widget.choices = self.fields['subevent'].choices
|
||
self.fields['subevent'].required = False
|
||
elif 'subevent':
|
||
del self.fields['subevent']
|
||
|
||
choices = []
|
||
prefix = (self.prefix + '-') if self.prefix else ''
|
||
if 'itemvar' in initial or (self.data and prefix + 'itemvar' in self.data):
|
||
iv = self.data.get(prefix + 'itemvar', '') or initial.get('itemvar', '') or ''
|
||
if iv.startswith('q-'):
|
||
q = self.event.quotas.get(pk=iv[2:])
|
||
choices.append(('q-%d' % q.pk, _('Any product in quota "{quota}"').format(quota=q)))
|
||
elif '-' in iv:
|
||
itemid, varid = iv.split('-')
|
||
i = self.event.items.get(pk=itemid)
|
||
v = i.variations.get(pk=varid)
|
||
choices.append(('%d-%d' % (i.pk, v.pk), '%s – %s' % (str(i), v.value)))
|
||
elif iv:
|
||
i = self.event.items.get(pk=iv)
|
||
if i.variations.exists():
|
||
choices.append((str(i.pk), _('{product} – Any variation').format(product=i)))
|
||
else:
|
||
choices.append((str(i.pk), str(i)))
|
||
|
||
self.fields['itemvar'].choices = choices
|
||
self.fields['itemvar'].widget = Select2ItemVarQuota(
|
||
attrs={
|
||
'data-model-select2': 'generic',
|
||
'data-select2-url': reverse('control:event.vouchers.itemselect2', kwargs={
|
||
'event': self.event.slug,
|
||
'organizer': self.event.organizer.slug,
|
||
}),
|
||
'data-placeholder': _('All products')
|
||
}
|
||
)
|
||
self.fields['itemvar'].required = False
|
||
self.fields['itemvar'].widget.choices = self.fields['itemvar'].choices
|
||
|
||
if self.event.seating_plan or self.event.subevents.filter(seating_plan__isnull=False).exists():
|
||
self.fields['seat'] = forms.CharField(
|
||
label=_("Specific seat ID"),
|
||
max_length=255,
|
||
required=False,
|
||
widget=forms.TextInput(attrs={'data-seat-guid-field': '1'}),
|
||
initial=self.instance.seat.seat_guid if self.instance.seat else '',
|
||
help_text=str(self.instance.seat) if self.instance.seat else '',
|
||
)
|
||
|
||
def parse_itemvar(self, data):
|
||
try:
|
||
itemid = quotaid = None
|
||
iv = data.get('itemvar', '')
|
||
if iv.startswith('q-'):
|
||
quotaid = iv[2:]
|
||
elif '-' in iv:
|
||
itemid, varid = iv.split('-')
|
||
elif iv:
|
||
itemid, varid = iv, None
|
||
else:
|
||
itemid, varid = None, None
|
||
|
||
if itemid:
|
||
item = self.event.items.get(pk=itemid)
|
||
if varid:
|
||
variation = item.variations.get(pk=varid)
|
||
else:
|
||
variation = None
|
||
quota = None
|
||
elif quotaid:
|
||
quota = self.event.quotas.get(pk=quotaid)
|
||
item = None
|
||
variation = None
|
||
else:
|
||
quota = None
|
||
item = None
|
||
variation = None
|
||
|
||
return (item, variation, quota)
|
||
|
||
except ObjectDoesNotExist:
|
||
raise ValidationError(_("Invalid product selected."))
|
||
|
||
def clean(self):
|
||
data = super().clean()
|
||
|
||
if not self._errors:
|
||
self.instance.item, self.instance.variation, self.instance.quota = self.parse_itemvar(self.data)
|
||
|
||
if 'codes' in data:
|
||
data['codes'] = [a.strip() for a in data.get('codes', '').strip().split("\n") if a]
|
||
cnt = len(data['codes']) * data.get('max_usages', 0)
|
||
else:
|
||
cnt = data.get('max_usages', 0)
|
||
if self.instance and self.instance.pk:
|
||
cnt -= self.instance.redeemed # these do not need quota any more
|
||
|
||
try:
|
||
Voucher.clean_item_properties(
|
||
data, self.event,
|
||
self.instance.quota, self.instance.item, self.instance.variation,
|
||
seats_given=data.get('seat') or data.get('seats'),
|
||
block_quota=data.get('block_quota')
|
||
)
|
||
except ValidationError as e:
|
||
raise ValidationError({"itemvar": e.message})
|
||
if not data.get('show_hidden_items') and (
|
||
(self.instance.quota and all(i.hide_without_voucher for i in self.instance.quota.items.all()))
|
||
or (self.instance.item and self.instance.item.hide_without_voucher)
|
||
):
|
||
raise ValidationError({
|
||
'show_hidden_items': [
|
||
_('The voucher only matches hidden products but you have not selected that it should show '
|
||
'them.')
|
||
]
|
||
})
|
||
|
||
try:
|
||
Voucher.clean_subevent(
|
||
data, self.event
|
||
)
|
||
except ValidationError as e:
|
||
raise ValidationError({"subevent": e.message})
|
||
try:
|
||
Voucher.clean_max_usages(data, self.instance.redeemed)
|
||
except ValidationError as e:
|
||
raise ValidationError({"max_usages": e})
|
||
check_quota = Voucher.clean_quota_needs_checking(
|
||
data, self.initial_instance_data,
|
||
item_changed=data.get('itemvar') != self.initial.get('itemvar'),
|
||
creating=not self.instance.pk
|
||
)
|
||
if check_quota:
|
||
Voucher.clean_quota_check(
|
||
data, cnt, self.initial_instance_data,
|
||
self.event, self.instance.quota, self.instance.item, self.instance.variation
|
||
)
|
||
Voucher.clean_voucher_code(data, self.event, self.instance.pk)
|
||
if 'seat' in self.fields:
|
||
if data.get('seat'):
|
||
self.instance.seat = Voucher.clean_seat_id(
|
||
data, self.instance.item, self.instance.quota, self.event, self.instance.pk
|
||
)
|
||
self.instance.item = self.instance.seat.product
|
||
else:
|
||
self.instance.seat = None
|
||
|
||
voucher_form_validation.send(sender=self.event, form=self, data=data)
|
||
|
||
return data
|
||
|
||
def save(self, commit=True):
|
||
return super().save(commit)
|
||
|
||
|
||
class VoucherBulkEditForm(VoucherForm):
|
||
def __init__(self, *args, **kwargs):
|
||
self.mixed_values = kwargs.pop('mixed_values')
|
||
self.queryset = kwargs.pop('queryset')
|
||
super().__init__(**kwargs)
|
||
del self.fields["code"]
|
||
self.fields.pop("seat", None)
|
||
|
||
def is_bulk_checked(self, fieldname):
|
||
return self.prefix + fieldname in self.data.getlist('_bulk')
|
||
|
||
def clean(self):
|
||
# We skip the parent class because it's not suited for bulk editing and implement custom validation here.
|
||
# This does not validate *everything* we validate in VoucherForm. For example, we skip validation that one does
|
||
# not create a voucher for an add-on product or that the seat matches the product to save on complexity.
|
||
# This is a UX validation only anyway, since one could first create the voucher and then make the product an
|
||
# add-on product. However, we need to validate everything that we don't want violated in the database.
|
||
data = super(VoucherForm, self).clean()
|
||
|
||
if self.is_bulk_checked("itemvar"):
|
||
data["item"], data["variation"], data["quota"] = self.parse_itemvar(data)
|
||
|
||
if self.is_bulk_checked("max_usages") and "max_usages" in data:
|
||
max_redeemed = self.queryset.aggregate(m=Max("redeemed"))["m"]
|
||
if data["max_usages"] < max_redeemed:
|
||
raise ValidationError(_(
|
||
"You cannot reduce the maximum number of redemptions to %(max_usages)s, because at least one "
|
||
"of the selected vouchers has already been redeemed %(max_redeemed)s times."
|
||
) % {"max_usages": data["max_usages"], "max_redeemed": max_redeemed})
|
||
|
||
# Check diff on product and quota usage based on old groups of vouchers
|
||
if any(self.is_bulk_checked(k) for k in ("max_usages", "itemvar", "block_quota", "valid_until", "subevent")):
|
||
quota_diff = Counter()
|
||
|
||
current_vouchers = self.queryset.order_by().values(
|
||
"item", "variation", "quota", "block_quota", "valid_until", "subevent", "redeemed", "max_usages",
|
||
"allow_ignore_quota",
|
||
).annotate(c=Count("*"))
|
||
item_cache = {i.pk: i for i in Item.objects.filter(pk__in=[c["item"] for c in current_vouchers])}
|
||
var_cache = {v.pk: v for v in ItemVariation.objects.filter(pk__in=[c["variation"] for c in current_vouchers])}
|
||
quota_cache = {q.pk: q for q in Quota.objects.filter(pk__in=[c["quota"] for c in current_vouchers])}
|
||
subevent_cache = {s.pk: s for s in SubEvent.objects.filter(pk__in=[c["subevent"] for c in current_vouchers])}
|
||
|
||
for current in current_vouchers:
|
||
bulk_count = current.pop('c')
|
||
current = VoucherBulkData(**current)
|
||
# Get quotas that are currently used
|
||
if current.item:
|
||
current.item = item_cache[current.item]
|
||
if current.variation:
|
||
current.variation = var_cache[current.variation]
|
||
if current.quota:
|
||
current.quota = quota_cache[current.quota]
|
||
if current.subevent:
|
||
current.subevent = subevent_cache[current.subevent]
|
||
|
||
old_quotas = Voucher.clean_quota_get_ignored(current)
|
||
old_amount = max(current.max_usages - current.redeemed, 0) * bulk_count
|
||
|
||
# Predict state after change
|
||
after_change = copy.copy(current)
|
||
if self.is_bulk_checked("itemvar") and "itemvar" in data:
|
||
after_change.item = data["item"]
|
||
after_change.variation = data["variation"]
|
||
after_change.quota = data["quota"]
|
||
if self.is_bulk_checked("subevent") and "subevent" in data:
|
||
after_change.subevent = data["subevent"]
|
||
if self.is_bulk_checked("max_usages") and "max_usages" in data:
|
||
after_change.max_usages = data["max_usages"]
|
||
if self.is_bulk_checked("block_quota") and "block_quota" in data:
|
||
after_change.block_quota = data["block_quota"]
|
||
if self.is_bulk_checked("valid_until") and "valid_until" in data:
|
||
after_change.valid_until = data["valid_until"]
|
||
if self.is_bulk_checked("allow_ignore_quota") and "allow_ignore_quota" in data:
|
||
after_change.allow_ignore_quota = data["allow_ignore_quota"]
|
||
|
||
if after_change.quota and self.event.has_subevents and not after_change.subevent:
|
||
raise ValidationError(_("You cannot create a voucher that allows selection of a quota but has no date selected."))
|
||
|
||
if after_change.quota and after_change.subevent and after_change.quota.subevent_id != after_change.subevent.pk:
|
||
raise ValidationError(_("The selected quota does not match the selected subevent."))
|
||
|
||
if after_change.block_quota and self.event.has_subevents and not after_change.subevent:
|
||
raise ValidationError(
|
||
_('If you want this voucher to block quota, you need to select a specific date.'))
|
||
|
||
if after_change.block_quota and not after_change.item and not after_change.quota:
|
||
raise ValidationError(
|
||
_('You need to select a specific product or quota if this voucher should reserve '
|
||
'tickets.')
|
||
)
|
||
|
||
if after_change.allow_ignore_quota:
|
||
# todo: is this the most useful way to do this?
|
||
continue
|
||
|
||
new_quotas = Voucher.clean_quota_get_ignored(after_change)
|
||
new_amount = max(after_change.max_usages - after_change.redeemed, 0) * bulk_count
|
||
|
||
if new_quotas != old_quotas or new_amount != old_amount:
|
||
for q in old_quotas:
|
||
quota_diff[q] -= old_amount
|
||
for q in new_quotas:
|
||
quota_diff[q] += new_amount
|
||
|
||
if any(v > 0 for q, v in quota_diff.items()):
|
||
lock_objects([q for q, v in quota_diff.items() if q.size is not None and v > 0], shared_lock_objects=[self.event])
|
||
qa = QuotaAvailability(count_waitinglist=False)
|
||
qa.queue(*(q for q, v in quota_diff.items() if v > 0))
|
||
qa.compute()
|
||
|
||
if any(qa.results[q][0] != Quota.AVAILABILITY_OK or (qa.results[q][1] is not None and qa.results[q][1] < required)
|
||
for q, required in quota_diff.items() if required > 0):
|
||
raise ValidationError(_(
|
||
'There is no sufficient quota available to perform this change.'
|
||
))
|
||
|
||
has_seat = self.queryset.filter(seat__isnull=False).exists()
|
||
if has_seat:
|
||
if self.is_bulk_checked("max_usages"):
|
||
raise ValidationError(_(
|
||
'Changing the maximum number of usages in bulk is not supported if any of the selected vouchers '
|
||
'is assigned a seat.'
|
||
))
|
||
if self.is_bulk_checked("subevent"):
|
||
raise ValidationError(pgettext_lazy(
|
||
'subevent',
|
||
'Changing the date in bulk is not supported if any of the selected vouchers '
|
||
'is assigned a seat.'
|
||
))
|
||
if self.is_bulk_checked("itemvar") and data["quota"]:
|
||
raise ValidationError(_(
|
||
'Changing the product to a quota is not supported if any of the selected vouchers '
|
||
'is assigned a seat.'
|
||
))
|
||
|
||
if self.is_bulk_checked("valid_until"):
|
||
if data["valid_until"] is None or data["valid_until"] >= now():
|
||
currently_not_blocked_seats = self.queryset.filter(
|
||
seat__isnull=False,
|
||
max_usages__gt=F("redeemed"),
|
||
valid_until__lt=now(),
|
||
)
|
||
if self.event.has_subevents:
|
||
subevents = self.event.subevents.filter(pk__in=currently_not_blocked_seats.values_list("subevent"))
|
||
for se in subevents:
|
||
conflicts = currently_not_blocked_seats.filter(
|
||
subevent=se
|
||
).exclude(
|
||
seat_id__in=se.free_seats().values("pk")
|
||
)
|
||
if conflicts:
|
||
raise ValidationError(_(
|
||
'This change cannot be completed because not all assigned seats of the vouchers are '
|
||
'still available'
|
||
))
|
||
else:
|
||
conflicts = currently_not_blocked_seats.exclude(
|
||
seat_id__in=self.event.free_seats().values("pk")
|
||
)
|
||
if conflicts:
|
||
raise ValidationError(_(
|
||
'This change cannot be completed because not all assigned seats of the vouchers are '
|
||
'still available'
|
||
))
|
||
|
||
return data
|
||
|
||
def save(self, commit=True):
|
||
objs = list(self.queryset)
|
||
fields = set()
|
||
|
||
check_map = {
|
||
'price_mode': '__price',
|
||
'value': '__price',
|
||
}
|
||
for k in self.fields:
|
||
if not self.is_bulk_checked(check_map.get(k, k)):
|
||
continue
|
||
|
||
if k == 'itemvar':
|
||
fields.add("item")
|
||
fields.add("variation")
|
||
fields.add("quota")
|
||
else:
|
||
fields.add(k)
|
||
for obj in objs:
|
||
if k == 'itemvar':
|
||
obj.item = self.cleaned_data["item"]
|
||
obj.variation = self.cleaned_data["variation"]
|
||
obj.quota = self.cleaned_data["quota"]
|
||
else:
|
||
setattr(obj, k, self.cleaned_data[k])
|
||
|
||
fields = [f for f in fields if f != 'itemvars']
|
||
if fields:
|
||
Voucher.objects.bulk_update(objs, fields, 200)
|
||
|
||
def full_clean(self):
|
||
if len(self.data) == 0:
|
||
# form wasn't submitted
|
||
self._errors = ErrorDict()
|
||
return
|
||
super().full_clean()
|
||
|
||
def _post_clean(self):
|
||
pass # skip model-level clean
|
||
|
||
|
||
class VoucherBulkForm(VoucherForm):
|
||
codes = forms.CharField(
|
||
widget=forms.Textarea,
|
||
label=_("Codes"),
|
||
help_text=_(
|
||
"Add one voucher code per line. We suggest that you copy this list and save it into a file."
|
||
),
|
||
required=True
|
||
)
|
||
send = forms.BooleanField(
|
||
label=_("Send vouchers via email"),
|
||
required=False
|
||
)
|
||
send_subject = forms.CharField(
|
||
label=_("Subject"),
|
||
widget=forms.TextInput(attrs={'data-display-dependency': '#id_send'}),
|
||
required=False,
|
||
initial=_('Your voucher for {event}')
|
||
)
|
||
send_message = forms.CharField(
|
||
label=_("Message"),
|
||
widget=MarkdownTextarea(attrs={'data-display-dependency': '#id_send'}),
|
||
required=False,
|
||
initial=_('Hello,\n\n'
|
||
'with this email, we\'re sending you one or more vouchers for {event}:\n\n{voucher_list}\n\n'
|
||
'You can redeem them here in our ticket shop:\n\n{url}\n\nBest regards, \n'
|
||
'Your {event} team')
|
||
)
|
||
send_recipients = forms.CharField(
|
||
label=_('Recipients'),
|
||
widget=forms.Textarea(attrs={
|
||
'data-display-dependency': '#id_send',
|
||
'placeholder': 'email,number,name,tag\njohn@example.org,3,John,example\n\n-- {} --\n\njohn@example.org\njane@example.net'.format(
|
||
_('or')
|
||
)
|
||
}),
|
||
required=False,
|
||
help_text=_('You can either supply a list of email addresses with one email address per line, or the contents '
|
||
'of a CSV file with a title row and one or more of the columns "email", "number", "name", '
|
||
'or "tag".')
|
||
)
|
||
Recipient = namedtuple('Recipient', 'email number name tag')
|
||
|
||
def _set_field_placeholders(self, fn, base_parameters, rich=False):
|
||
placeholders = get_available_placeholders(self.instance.event, base_parameters, rich=rich)
|
||
ht = format_placeholders_help_text(placeholders, self.instance.event)
|
||
|
||
if self.fields[fn].help_text:
|
||
self.fields[fn].help_text += ' ' + str(ht)
|
||
else:
|
||
self.fields[fn].help_text = ht
|
||
self.fields[fn].validators.append(
|
||
PlaceholderValidator(['{%s}' % p for p in placeholders.keys()])
|
||
)
|
||
|
||
class Meta:
|
||
model = Voucher
|
||
localized_fields = '__all__'
|
||
fields = [
|
||
'valid_until', 'block_quota', 'allow_ignore_quota', 'value', 'tag', 'comment',
|
||
'max_usages', 'min_usages', 'price_mode', 'subevent', 'show_hidden_items', 'all_addons_included',
|
||
'all_bundles_included', 'budget'
|
||
]
|
||
field_classes = {
|
||
'valid_until': SplitDateTimeField,
|
||
'subevent': SafeModelChoiceField,
|
||
}
|
||
widgets = {
|
||
'valid_until': SplitDateTimePickerWidget(),
|
||
}
|
||
labels = {
|
||
'max_usages': _('Maximum usages per voucher')
|
||
}
|
||
help_texts = {
|
||
'max_usages': _('Number of times times EACH of these vouchers can be redeemed.')
|
||
}
|
||
|
||
def __init__(self, *args, **kwargs):
|
||
super().__init__(*args, **kwargs)
|
||
self._set_field_placeholders('send_subject', ['event', 'name'])
|
||
self._set_field_placeholders('send_message', ['event', 'voucher_list', 'name'], rich=True)
|
||
|
||
with language(self.instance.event.settings.locale, self.instance.event.settings.region):
|
||
for f in ("send_subject", "send_message"):
|
||
self.fields[f].initial = str(self.fields[f].initial)
|
||
|
||
if 'seat' in self.fields:
|
||
self.fields['seats'] = forms.CharField(
|
||
label=_("Specific seat IDs"),
|
||
required=False,
|
||
widget=forms.Textarea(attrs={'data-seat-guid-field': '1'}),
|
||
initial=self.instance.seat.seat_guid if self.instance.seat else '',
|
||
)
|
||
|
||
def clean_send_recipients(self):
|
||
raw = self.cleaned_data['send_recipients']
|
||
if self.cleaned_data.get('send', None) is False:
|
||
# No need to validate addresses if the section was turned off
|
||
return []
|
||
if not raw:
|
||
return []
|
||
r = raw.split('\n')
|
||
res = []
|
||
if ',' in raw or ';' in raw:
|
||
if '@' in r[0]:
|
||
raise ValidationError(_('CSV input needs to contain a header row in the first line.'))
|
||
try:
|
||
dialect = csv.Sniffer().sniff(raw[:1024])
|
||
reader = csv.DictReader(StringIO(raw), dialect=dialect)
|
||
except csv.Error as e:
|
||
raise ValidationError(_('CSV parsing failed: {error}.').format(error=str(e)))
|
||
if len(reader.fieldnames) == 1 and ',' in reader.fieldnames[0]:
|
||
raise ValidationError(_('CSV input was not recognized to have multiple columns, maybe you have some invalid quoted field in your input.'))
|
||
if 'email' not in reader.fieldnames:
|
||
raise ValidationError(_('CSV input needs to contain a field with the header "{header}".').format(header="email"))
|
||
unknown_fields = [f for f in reader.fieldnames if f not in ('email', 'name', 'tag', 'number')]
|
||
if unknown_fields:
|
||
raise ValidationError(_('CSV input contains an unknown field with the header "{header}".').format(header=unknown_fields[0]))
|
||
for i, row in enumerate(reader):
|
||
try:
|
||
EmailValidator()(row['email'].strip())
|
||
except ValidationError as err:
|
||
raise ValidationError(_('{value} is not a valid email address.').format(value=row['email'].strip())) from err
|
||
try:
|
||
res.append(self.Recipient(
|
||
name=row.get('name', ''),
|
||
email=row['email'].strip(),
|
||
number=int(row.get('number', 1) or ""),
|
||
tag=row.get('tag', None)
|
||
))
|
||
except ValueError as err:
|
||
raise ValidationError(_('Invalid value in row {number}.').format(number=i + 1)) from err
|
||
else:
|
||
for e in r:
|
||
try:
|
||
EmailValidator()(e.strip())
|
||
except ValidationError as err:
|
||
raise ValidationError(_('{value} is not a valid email address.').format(value=e.strip())) from err
|
||
else:
|
||
res.append(self.Recipient(email=e.strip(), number=1, tag=None, name=''))
|
||
return res
|
||
|
||
def clean(self):
|
||
data = super().clean()
|
||
|
||
if 'codes' in data:
|
||
vouchers = self.instance.event.vouchers.annotate(
|
||
code_upper=Upper('code')
|
||
).filter(code_upper__in=[c.upper() for c in data['codes']])
|
||
if vouchers.exists():
|
||
raise ValidationError(_('A voucher with one of these codes already exists.'))
|
||
|
||
codes_seen = set()
|
||
for c in data['codes']:
|
||
if len(c) < 5:
|
||
raise ValidationError({
|
||
'codes': [
|
||
_('The voucher code {code} is too short. Make sure all voucher codes are at least {min_length} characters long.').format(
|
||
code=c,
|
||
min_length=5
|
||
)
|
||
]
|
||
})
|
||
if c in codes_seen:
|
||
raise ValidationError(_('The voucher code {code} appears in your list twice.').format(code=c))
|
||
codes_seen.add(c)
|
||
|
||
if data.get('send') and not all([data.get('send_subject'), data.get('send_message'), data.get('send_recipients')]):
|
||
raise ValidationError(_('If vouchers should be sent by email, subject, message and recipients need to be specified.'))
|
||
|
||
if data.get('codes') and data.get('send'):
|
||
recp = self.cleaned_data.get('send_recipients', [])
|
||
code_len = len(data.get('codes'))
|
||
recp_len = sum(r.number for r in recp)
|
||
if code_len != recp_len:
|
||
raise ValidationError(_('You generated {codes} vouchers, but entered recipients for {recp} vouchers.').format(codes=code_len, recp=recp_len))
|
||
|
||
if data.get('seats'):
|
||
seatids = [s.strip() for s in data.get('seats').strip().split("\n") if s]
|
||
if len(seatids) != len(data.get('codes')):
|
||
raise ValidationError(_('You need to specify as many seats as voucher codes.'))
|
||
data['seats'] = []
|
||
for s in seatids:
|
||
data['seat'] = s
|
||
data['seats'].append(Voucher.clean_seat_id(
|
||
data, self.instance.item, self.instance.quota, self.instance.event, None
|
||
))
|
||
self.instance.seat = data['seats'][0] # Trick model-level validation
|
||
else:
|
||
data['seats'] = []
|
||
|
||
return data
|
||
|
||
def post_bulk_save(self, objs):
|
||
pass
|