Add support for reserved seating (#1228)

* Initial work on seating

* Add seat guids

* Add product_list_top

* CartAdd: Ignore item when a seat is passed

* Cart display

* product_list_top → render_seating_plan

* Render seating plan in voucher redemption

* Fix failing tests

* Add tests for extending cart positions with seats

* Add subevent_forms to docs

* Update schema, migrations

* Dealing with expired orders

* steps to order change

* Change order positions

* Allow to add seats

* tests for ocm

* Fix things after rebase

* Seating plans API

* Add more tests for cart behaviour

* Widget support

* Adjust widget tests

* Re-enable CSP

* Update schema

* Api: position.seat

* Add guid to word list

* API: (sub)event.seating_plan

* Vali fixes

* Fix api

* Fix reference in test

* Fix test for real

src/pretix/base/services/cart.py

@@ -6,7 +6,7 @@ from typing import List, Optional
 from celery.exceptions import MaxRetriesExceededError
 from django.core.exceptions import ValidationError
 from django.db import DatabaseError, transaction
-from django.db.models import Q
+from django.db.models import Count, Exists, OuterRef, Q
 from django.dispatch import receiver
 from django.utils.timezone import make_aware, now
 from django.utils.translation import pgettext_lazy, ugettext as _
@@ -14,8 +14,8 @@ from django_scopes import scopes_disabled
 
 from pretix.base.i18n import language
 from pretix.base.models import (
-    CartPosition, Event, InvoiceAddress, Item, ItemBundle, ItemVariation,
-    Voucher,
+    CartPosition, Event, InvoiceAddress, Item, ItemBundle, ItemVariation, Seat,
+    SeatCategoryMapping, Voucher,
 )
 from pretix.base.models.event import SubEvent
 from pretix.base.models.orders import OrderFee
@@ -91,15 +91,20 @@ error_messages = {
                          'product %(base)s.'),
     'addon_only': _('One of the products you selected can only be bought as an add-on to another project.'),
     'bundled_only': _('One of the products you selected can only be bought part of a bundle.'),
+    'seat_required': _('You need to select a specific seat.'),
+    'seat_invalid': _('Please select a valid seat.'),
+    'seat_forbidden': _('You can not select a seat for this position.'),
+    'seat_unavailable': _('The seat you selected has already been taken. Please select a different seat.'),
+    'seat_multiple': _('You can not select the same seat multiple times.'),
 }
 
 
 class CartManager:
     AddOperation = namedtuple('AddOperation', ('count', 'item', 'variation', 'price', 'voucher', 'quotas',
-                                               'addon_to', 'subevent', 'includes_tax', 'bundled'))
+                                               'addon_to', 'subevent', 'includes_tax', 'bundled', 'seat'))
     RemoveOperation = namedtuple('RemoveOperation', ('position',))
     ExtendOperation = namedtuple('ExtendOperation', ('position', 'count', 'item', 'variation', 'price', 'voucher',
-                                                     'quotas', 'subevent'))
+                                                     'quotas', 'subevent', 'seat'))
     order = {
         RemoveOperation: 10,
         ExtendOperation: 20,
@@ -117,6 +122,7 @@ class CartManager:
         self._items_cache = {}
         self._subevents_cache = {}
         self._variations_cache = {}
+        self._seated_cache = {}
         self._expiry = None
         self.invoice_address = invoice_address
         self._widget_data = widget_data or {}
@@ -128,6 +134,11 @@ class CartManager:
             Q(cart_id=self.cart_id) & Q(event=self.event)
         ).select_related('item', 'subevent')
 
+    def _is_seated(self, item, subevent):
+        if (item, subevent) not in self._seated_cache:
+            self._seated_cache[item, subevent] = item.seat_category_mappings.filter(subevent=subevent).exists()
+        return self._seated_cache[item, subevent]
+
     def _calculate_expiry(self):
         self._expiry = self.now_dt + timedelta(minutes=self.event.settings.get('reservation_time', as_type=int))
 
@@ -188,6 +199,8 @@ class CartManager:
             i.pk: i
             for i in self.event.items.select_related('category').prefetch_related(
                 'addons', 'bundles', 'addons__addon_category', 'quotas'
+            ).annotate(
+                has_variations=Count('variations'),
             ).filter(
                 id__in=[i for i in item_ids if i and i not in self._items_cache]
             )
@@ -224,6 +237,12 @@ class CartManager:
             if self._sales_channel not in op.item.sales_channels:
                 raise CartError(error_messages['unavailable'])
 
+            if op.item.has_variations and not op.variation:
+                raise CartError(error_messages['not_for_sale'])
+
+            if op.variation and op.variation.item_id != op.item.pk:
+                raise CartError(error_messages['not_for_sale'])
+
             if op.voucher and not op.voucher.applies_to(op.item, op.variation):
                 raise CartError(error_messages['voucher_invalid_item'])
 
@@ -239,6 +258,16 @@ class CartManager:
             if op.subevent and op.subevent.presale_has_ended:
                 raise CartError(error_messages['ended'])
 
+            seated = self._is_seated(op.item, op.subevent)
+            if seated and (not op.seat or op.seat.blocked):
+                raise CartError(error_messages['seat_invalid'])
+            elif op.seat and not seated:
+                raise CartError(error_messages['seat_forbidden'])
+            elif op.seat and op.seat.product != op.item:
+                raise CartError(error_messages['seat_invalid'])
+            elif op.seat and op.count > 1:
+                raise CartError('Invalid request: A seat can only be bought once.')
+
             if op.subevent:
                 tlv = self.event.settings.get('payment_term_last', as_type=RelativeDateWrapper)
                 if tlv:
@@ -301,6 +330,13 @@ class CartManager:
     def extend_expired_positions(self):
         expired = self.positions.filter(expires__lte=self.now_dt).select_related(
             'item', 'variation', 'voucher', 'addon_to', 'addon_to__item'
+        ).annotate(
+            requires_seat=Exists(
+                SeatCategoryMapping.objects.filter(
+                    Q(product=OuterRef('item'))
+                    & (Q(subevent=OuterRef('subevent')) if self.event.has_subevents else Q(subevent__isnull=True))
+                )
+            )
         ).prefetch_related(
             'item__quotas',
             'variation__quotas',
@@ -313,6 +349,8 @@ class CartManager:
             if cp.pk in removed_positions or (cp.addon_to_id and cp.addon_to_id in removed_positions):
                 continue
 
+            cp.item.requires_seat = cp.requires_seat
+
             if cp.is_bundled:
                 try:
                     bundle = cp.addon_to.item.bundles.get(bundled_item=cp.item, bundled_variation=cp.variation)
@@ -359,7 +397,7 @@ class CartManager:
 
             op = self.ExtendOperation(
                 position=cp, item=cp.item, variation=cp.variation, voucher=cp.voucher, count=1,
-                price=price, quotas=quotas, subevent=cp.subevent
+                price=price, quotas=quotas, subevent=cp.subevent, seat=cp.seat
             )
             self._check_item_constraints(op)
 
@@ -378,12 +416,6 @@ class CartManager:
         operations = []
 
         for i in items:
-            # Check whether the specified items are part of what we just fetched from the database
-            # If they are not, the user supplied item IDs which either do not exist or belong to
-            # a different event
-            if i['item'] not in self._items_cache or (i['variation'] and i['variation'] not in self._variations_cache):
-                raise CartError(error_messages['not_for_sale'])
-
             if self.event.has_subevents:
                 if not i.get('subevent'):
                     raise CartError(error_messages['subevent_required'])
@@ -391,6 +423,24 @@ class CartManager:
             else:
                 subevent = None
 
+            # When a seat is given, we ignore the item that was given, since we can infer it from the
+            # seat. The variation is still relevant, though!
+            seat = None
+            if i.get('seat'):
+                try:
+                    seat = (subevent or self.event).seats.get(seat_guid=i.get('seat'))
+                except Seat.DoesNotExist:
+                    raise CartError(error_messages['seat_invalid'])
+                i['item'] = seat.product_id
+                if i['item'] not in self._items_cache:
+                    self._update_items_cache([i['item']], [i['variation']])
+
+            # Check whether the specified items are part of what we just fetched from the database
+            # If they are not, the user supplied item IDs which either do not exist or belong to
+            # a different event
+            if i['item'] not in self._items_cache or (i['variation'] and i['variation'] not in self._variations_cache):
+                raise CartError(error_messages['not_for_sale'])
+
             item = self._items_cache[i['item']]
             variation = self._variations_cache[i['variation']] if i['variation'] is not None else None
             voucher = None
@@ -446,7 +496,7 @@ class CartManager:
                 bop = self.AddOperation(
                     count=bundle.count, item=bitem, variation=bvar, price=bprice,
                     voucher=None, quotas=bundle_quotas, addon_to='FAKE', subevent=subevent,
-                    includes_tax=bool(bprice.rate), bundled=[]
+                    includes_tax=bool(bprice.rate), bundled=[], seat=None
                 )
                 self._check_item_constraints(bop)
                 bundled.append(bop)
@@ -455,7 +505,7 @@ class CartManager:
 
             op = self.AddOperation(
                 count=i['count'], item=item, variation=variation, price=price, voucher=voucher, quotas=quotas,
-                addon_to=False, subevent=subevent, includes_tax=bool(price.rate), bundled=bundled
+                addon_to=False, subevent=subevent, includes_tax=bool(price.rate), bundled=bundled, seat=seat
             )
             self._check_item_constraints(op)
             operations.append(op)
@@ -561,7 +611,7 @@ class CartManager:
 
                 op = self.AddOperation(
                     count=1, item=item, variation=variation, price=price, voucher=None, quotas=quotas,
-                    addon_to=cp, subevent=cp.subevent, includes_tax=bool(price.rate), bundled=[]
+                    addon_to=cp, subevent=cp.subevent, includes_tax=bool(price.rate), bundled=[], seat=cp.seat
                 )
                 self._check_item_constraints(op)
                 operations.append(op)
@@ -687,6 +737,7 @@ class CartManager:
         err = err or self._check_min_per_product()
 
         self._operations.sort(key=lambda a: self.order[type(a)])
+        seats_seen = set()
 
         for op in self._operations:
             if isinstance(op, self.RemoveOperation):
@@ -700,6 +751,11 @@ class CartManager:
                 # Create a CartPosition for as much items as we can
                 requested_count = quota_available_count = voucher_available_count = op.count
 
+                if op.seat:
+                    if op.seat in seats_seen:
+                        err = err or error_messages['seat_multiple']
+                    seats_seen.add(op.seat)
+
                 if op.quotas:
                     quota_available_count = min(requested_count, min(quotas_ok[q] for q in op.quotas))
 
@@ -745,12 +801,16 @@ class CartManager:
                     available_count = 0
 
                 if isinstance(op, self.AddOperation):
+                    if op.seat and not op.seat.is_available():
+                        available_count = 0
+                        err = err or error_messages['seat_unavailable']
+
                     for k in range(available_count):
                         cp = CartPosition(
                             event=self.event, item=op.item, variation=op.variation,
                             price=op.price.gross, expires=self._expiry, cart_id=self.cart_id,
                             voucher=op.voucher, addon_to=op.addon_to if op.addon_to else None,
-                            subevent=op.subevent, includes_tax=op.includes_tax
+                            subevent=op.subevent, includes_tax=op.includes_tax, seat=op.seat
                         )
                         if self.event.settings.attendee_names_asked:
                             scheme = PERSON_NAME_SCHEMES.get(self.event.settings.name_scheme)
@@ -789,7 +849,11 @@ class CartManager:
 
                         new_cart_positions.append(cp)
                 elif isinstance(op, self.ExtendOperation):
-                    if available_count == 1:
+                    if op.seat and not op.seat.is_available(ignore_cart=op.position):
+                        err = err or error_messages['seat_unavailable']
+                        op.position.addons.all().delete()
+                        op.position.delete()
+                    elif available_count == 1:
                         op.position.expires = self._expiry
                         op.position.price = op.price.gross
                         try:
@@ -820,6 +884,9 @@ class CartManager:
             # If any quotas are affected that are not unlimited, we lock
             return True
 
+        if any(getattr(o, 'seat', False) for o in self._operations):
+            return True
+
         return False
 
     def commit(self):
@@ -909,7 +976,7 @@ def add_items_to_cart(self, event: int, items: List[dict], cart_id: str=None, lo
     """
     Adds a list of items to a user's cart.
     :param event: The event ID in question
-    :param items: A list of dicts with the keys item, variation, count, custom_price, voucher
+    :param items: A list of dicts with the keys item, variation, count, custom_price, voucher, seat ID
     :param cart_id: Session ID of a guest
     :raises CartError: On any error that occured
     """

src/pretix/base/services/orders.py

@@ -24,7 +24,7 @@ from pretix.base.i18n import (
 )
 from pretix.base.models import (
     CartPosition, Device, Event, Item, ItemVariation, Order, OrderPayment,
-    OrderPosition, Quota, User, Voucher,
+    OrderPosition, Quota, Seat, SeatCategoryMapping, User, Voucher,
 )
 from pretix.base.models.event import SubEvent
 from pretix.base.models.items import ItemBundle
@@ -82,6 +82,8 @@ error_messages = {
                                    'affected positions have been removed from your cart.'),
     'some_subevent_ended': _('The presale period for one of the events in your cart has ended. The affected '
                              'positions have been removed from your cart.'),
+    'seat_invalid': _('One of the seats in your order was invalid, we removed the position from your cart.'),
+    'seat_unavailable': _('One of the seats in your order has been taken in the meantime, we removed the position from your cart.'),
 }
 
 logger = logging.getLogger(__name__)
@@ -428,6 +430,7 @@ def _check_positions(event: Event, now_dt: datetime, positions: List[CartPositio
     products_seen = Counter()
     changed_prices = {}
     deleted_positions = set()
+    seats_seen = set()
 
     def delete(cp):
         # Delete a cart position, including parents and children, if applicable
@@ -490,6 +493,13 @@ def _check_positions(event: Event, now_dt: datetime, positions: List[CartPositio
             delete(cp)
             break
 
+        if (cp.requires_seat and not cp.seat) or (cp.seat and not cp.requires_seat) or (cp.seat and cp.seat.product != cp.item) or cp.seat in seats_seen:
+            err = err or error_messages['seat_invalid']
+            delete(cp)
+            break
+        if cp.seat:
+            seats_seen.add(cp.seat)
+
         if cp.item.require_voucher and cp.voucher is None:
             delete(cp)
             err = err or error_messages['voucher_required']
@@ -501,6 +511,14 @@ def _check_positions(event: Event, now_dt: datetime, positions: List[CartPositio
             err = error_messages['voucher_required']
             break
 
+        if cp.seat:
+            # Unlike quotas (which we blindly trust as long as the position is not expired), we check seats every time, since we absolutely
+            # can not overbook a seat.
+            if not cp.seat.is_available(ignore_cart=cp) or cp.seat.blocked:
+                err = err or error_messages['seat_unavailable']
+                cp.delete()
+                continue
+
         if cp.expires >= now_dt and not cp.voucher:
             # Other checks are not necessary
             continue
@@ -736,21 +754,30 @@ def _perform_order(event: Event, payment_provider: str, position_ids: List[str],
         except InvoiceAddress.DoesNotExist:
             pass
 
-    positions = CartPosition.objects.filter(id__in=position_ids, event=event)
+    positions = CartPosition.objects.annotate(
+        requires_seat=Exists(
+            SeatCategoryMapping.objects.filter(
+                Q(product=OuterRef('item'))
+                & (Q(subevent=OuterRef('subevent')) if event.has_subevents else Q(subevent__isnull=True))
+            )
+        )
+    ).filter(
+        id__in=position_ids, event=event
+    )
 
     validate_order.send(event, payment_provider=pprov, email=email, positions=positions,
                         locale=locale, invoice_address=addr, meta_info=meta_info)
 
     lockfn = NoLockManager
     locked = False
-    if positions.filter(Q(voucher__isnull=False) | Q(expires__lt=now() + timedelta(minutes=2))).exists():
+    if positions.filter(Q(voucher__isnull=False) | Q(expires__lt=now() + timedelta(minutes=2)) | Q(seat__isnull=False)).exists():
         # Performance optimization: If no voucher is used and no cart position is dangerously close to its expiry date,
         # creating this order shouldn't be prone to any race conditions and we don't need to lock the event.
         locked = True
         lockfn = event.lock
 
     with lockfn() as now_dt:
-        positions = list(positions.select_related('item', 'variation', 'subevent', 'addon_to').prefetch_related('addons'))
+        positions = list(positions.select_related('item', 'variation', 'subevent', 'seat', 'addon_to').prefetch_related('addons'))
         if len(positions) == 0:
             raise OrderError(error_messages['empty'])
         if len(position_ids) != len(positions):
@@ -961,12 +988,17 @@ class OrderChangeManager:
         'addon_to_required': _('This is an add-on product, please select the base position it should be added to.'),
         'addon_invalid': _('The selected base position does not allow you to add this product as an add-on.'),
         'subevent_required': _('You need to choose a subevent for the new position.'),
+        'seat_unavailable': _('The selected seat "{seat}" is not available.'),
+        'seat_subevent_mismatch': _('You selected seat "{seat}" for a date that does not match the selected ticket date. Please choose a seat again.'),
+        'seat_required': _('The selected product requires you to select a seat.'),
+        'seat_forbidden': _('The selected product does not allow to select a seat.'),
     }
     ItemOperation = namedtuple('ItemOperation', ('position', 'item', 'variation'))
     SubeventOperation = namedtuple('SubeventOperation', ('position', 'subevent'))
+    SeatOperation = namedtuple('SubeventOperation', ('position', 'seat'))
     PriceOperation = namedtuple('PriceOperation', ('position', 'price'))
     CancelOperation = namedtuple('CancelOperation', ('position',))
-    AddOperation = namedtuple('AddOperation', ('item', 'variation', 'price', 'addon_to', 'subevent'))
+    AddOperation = namedtuple('AddOperation', ('item', 'variation', 'price', 'addon_to', 'subevent', 'seat'))
     SplitOperation = namedtuple('SplitOperation', ('position',))
     RegenerateSecretOperation = namedtuple('RegenerateSecretOperation', ('position',))
 
@@ -979,6 +1011,7 @@ class OrderChangeManager:
         self._committed = False
         self._totaldiff = 0
         self._quotadiff = Counter()
+        self._seatdiff = Counter()
         self._operations = []
         self.notify = notify
         self._invoice_dirty = False
@@ -996,6 +1029,13 @@ class OrderChangeManager:
         self._quotadiff.subtract(position.quotas)
         self._operations.append(self.ItemOperation(position, item, variation))
 
+    def change_seat(self, position: OrderPosition, seat: Seat):
+        if position.seat:
+            self._seatdiff.subtract([position.seat])
+        if seat:
+            self._seatdiff.update([seat])
+        self._operations.append(self.SeatOperation(position, seat))
+
     def change_subevent(self, position: OrderPosition, subevent: SubEvent):
         price = get_price(position.item, position.variation, voucher=position.voucher, subevent=subevent,
                           invoice_address=self._invoice_address)
@@ -1051,12 +1091,14 @@ class OrderChangeManager:
         self._totaldiff += -position.price
         self._quotadiff.subtract(position.quotas)
         self._operations.append(self.CancelOperation(position))
+        if position.seat:
+            self._seatdiff.subtract([position.seat])
 
         if self.order.event.settings.invoice_include_free or position.price != Decimal('0.00'):
             self._invoice_dirty = True
 
     def add_position(self, item: Item, variation: ItemVariation, price: Decimal, addon_to: Order = None,
-                     subevent: SubEvent = None):
+                     subevent: SubEvent = None, seat: Seat = None):
         if price is None:
             price = get_price(item, variation, subevent=subevent, invoice_address=self._invoice_address)
         else:
@@ -1075,6 +1117,14 @@ class OrderChangeManager:
         if self.order.event.has_subevents and not subevent:
             raise OrderError(self.error_messages['subevent_required'])
 
+        seated = item.seat_category_mappings.filter(subevent=subevent).exists()
+        if seated and not seat:
+            raise OrderError(self.error_messages['seat_required'])
+        elif not seated and seat:
+            raise OrderError(self.error_messages['seat_forbidden'])
+        if seat and subevent and seat.subevent_id != subevent:
+            raise OrderError(self.error_messages['seat_subevent_mismatch'].format(seat=seat.name))
+
         new_quotas = (variation.quotas.filter(subevent=subevent)
                       if variation else item.quotas.filter(subevent=subevent))
         if not new_quotas:
@@ -1085,7 +1135,9 @@ class OrderChangeManager:
 
         self._totaldiff += price.gross
         self._quotadiff.update(new_quotas)
-        self._operations.append(self.AddOperation(item, variation, price, addon_to, subevent))
+        if seat:
+            self._seatdiff.update([seat])
+        self._operations.append(self.AddOperation(item, variation, price, addon_to, subevent, seat))
 
     def split(self, position: OrderPosition):
         if self.order.event.settings.invoice_include_free or position.price != Decimal('0.00'):
@@ -1093,6 +1145,26 @@ class OrderChangeManager:
 
         self._operations.append(self.SplitOperation(position))
 
+    def _check_seats(self):
+        for seat, diff in self._seatdiff.items():
+            if diff <= 0:
+                continue
+            if not seat.is_available() or diff > 1:
+                raise OrderError(self.error_messages['seat_unavailable'].format(seat=seat.name))
+
+        if self.event.has_subevents:
+            state = {}
+            for p in self.order.positions.all():
+                state[p] = {'seat': p.seat, 'subevent': p.subevent}
+            for op in self._operations:
+                if isinstance(op, self.SeatOperation):
+                    state[op.position]['seat'] = op.seat
+                elif isinstance(op, self.SubeventOperation):
+                    state[op.position]['subevent'] = op.subevent
+            for v in state.values():
+                if v['seat'] and v['seat'].subevent_id != v['subevent'].pk:
+                    raise OrderError(self.error_messages['seat_subevent_mismatch'].format(seat=v['seat'].name))
+
     def _check_quotas(self):
         for quota, diff in self._quotadiff.items():
             if diff <= 0:
@@ -1179,6 +1251,17 @@ class OrderChangeManager:
                 op.position.variation = op.variation
                 op.position._calculate_tax()
                 op.position.save()
+            elif isinstance(op, self.SeatOperation):
+                self.order.log_action('pretix.event.order.changed.seat', user=self.user, auth=self.auth, data={
+                    'position': op.position.pk,
+                    'positionid': op.position.positionid,
+                    'old_seat': op.position.seat.name if op.position.seat else "-",
+                    'new_seat': op.seat.name if op.seat else "-",
+                    'old_seat_id': op.position.seat.pk if op.position.seat else None,
+                    'new_seat_id': op.seat.pk if op.seat else None,
+                })
+                op.position.seat = op.seat
+                op.position.save()
             elif isinstance(op, self.SubeventOperation):
                 self.order.log_action('pretix.event.order.changed.subevent', user=self.user, auth=self.auth, data={
                     'position': op.position.pk,
@@ -1232,7 +1315,7 @@ class OrderChangeManager:
                     item=op.item, variation=op.variation, addon_to=op.addon_to,
                     price=op.price.gross, order=self.order, tax_rate=op.price.rate,
                     tax_value=op.price.tax, tax_rule=op.item.tax_rule,
-                    positionid=nextposid, subevent=op.subevent
+                    positionid=nextposid, subevent=op.subevent, seat=op.seat
                 )
                 nextposid += 1
                 self.order.log_action('pretix.event.order.changed.add', user=self.user, auth=self.auth, data={
@@ -1243,6 +1326,7 @@ class OrderChangeManager:
                     'price': op.price.gross,
                     'positionid': pos.positionid,
                     'subevent': op.subevent.pk if op.subevent else None,
+                    'seat': op.seat.pk if op.seat else None,
                 })
             elif isinstance(op, self.SplitOperation):
                 split_positions.append(op.position)
@@ -1467,6 +1551,7 @@ class OrderChangeManager:
                     raise OrderError(self.error_messages['not_pending_or_paid'])
                 if check_quotas:
                     self._check_quotas()
+                self._check_seats()
                 self._check_complete_cancel()
                 self._perform_operations()
             self._recalculate_total_and_payment_fee()

src/pretix/base/services/seating.py

@@ -0,0 +1,57 @@
+from django.db.models import Count
+from django.utils.translation import ugettext_lazy as _
+
+from pretix.base.models import CartPosition, Seat
+
+
+class SeatProtected(Exception):
+    pass
+
+
+def validate_plan_change(event, subevent, plan):
+    current_taken_seats = set(
+        event.seats.select_related('product')
+             .annotate(has_op=Count('orderposition'))
+             .filter(subevent=subevent, has_op=True)
+             .values_list('seat_guid', flat=True)
+    )
+    new_seats = {
+        ss.guid for ss in plan.iter_all_seats()
+    } if plan else set()
+    leftovers = list(current_taken_seats - new_seats)
+    if leftovers:
+        raise SeatProtected(_('You can not change the plan since seat "{}" is not present in the new plan and is '
+                              'already sold.').format(leftovers[0]))
+
+
+def generate_seats(event, subevent, plan, mapping):
+    current_seats = {
+        s.seat_guid: s for s in
+        event.seats.select_related('product').annotate(has_op=Count('orderposition')).filter(subevent=subevent)
+    }
+    create_seats = []
+    if plan:
+        for ss in plan.iter_all_seats():
+            p = mapping.get(ss.category)
+            if ss.guid in current_seats:
+                seat = current_seats.pop(ss.guid)
+                if seat.product != p:
+                    seat.product = p
+                    seat.save()
+            else:
+                create_seats.append(Seat(
+                    event=event,
+                    subevent=subevent,
+                    seat_guid=ss.guid,
+                    name=ss.name,
+                    product=p,
+                ))
+
+    for s in current_seats.values():
+        if s.has_op:
+            raise SeatProtected(_('You can not change the plan since seat "{}" is not present in the new plan and is '
+                                  'already sold.').format(s.name))
+
+    Seat.objects.bulk_create(create_seats)
+    CartPosition.objects.filter(seat__in=[s.pk for s in current_seats.values()]).delete()
+    Seat.objects.filter(pk__in=[s.pk for s in current_seats.values()]).delete()