Cross selling (#4185)

Product categories can now be marked as "cross-selling categories", causing them to 
appear in the add-on checkout step as additional recommendations, depending on 
their cross-selling visibility (always, only if certain products are already in the cart, or 
only if they qualify for a discount according to discount rules).

---------

Co-authored-by: Raphael Michel <michel@rami.io>
Co-authored-by: Richard Schreiber <schreiber@rami.io>

src/pretix/base/migrations/0271_itemcategory_cross_selling.py

@@ -0,0 +1,32 @@
+# Generated by Django 4.2.11 on 2024-05-27 13:19
+
+from django.db import migrations, models
+
+import pretix.base.models.orders
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("pretixbase", "0270_historicpassword"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="itemcategory",
+            name="cross_selling_condition",
+            field=models.CharField(null=True, max_length=10),
+        ),
+        migrations.AddField(
+            model_name="itemcategory",
+            name="cross_selling_mode",
+            field=models.CharField(null=True, max_length=5),
+        ),
+        migrations.AddField(
+            model_name="itemcategory",
+            name="cross_selling_match_products",
+            field=models.ManyToManyField(
+                related_name="matched_by_cross_selling_categories", to="pretixbase.item"
+            ),
+        ),
+    ]

src/pretix/base/models/discount.py

@@ -20,11 +20,11 @@
 # <https://www.gnu.org/licenses/>.
 #
 
-from collections import defaultdict
+from collections import defaultdict, namedtuple
 from decimal import Decimal
 from itertools import groupby
-from math import ceil
-from typing import Dict, Optional, Tuple
+from math import ceil, inf
+from typing import Dict
 
 from django.core.exceptions import ValidationError
 from django.core.validators import MinValueValidator
@@ -36,6 +36,8 @@ from django_scopes import ScopedManager
 from pretix.base.decimal import round_decimal
 from pretix.base.models.base import LoggedModel
 
+PositionInfo = namedtuple('PositionInfo', ['item_id', 'subevent_id', 'line_price_gross', 'is_addon_to', 'voucher_discount'])
+
 
 class Discount(LoggedModel):
     SUBEVENT_MODE_MIXED = 'mixed'
@@ -245,22 +247,26 @@ class Discount(LoggedModel):
             return False
         return True
 
-    def _apply_min_value(self, positions, condition_idx_group, benefit_idx_group, result):
-        if self.condition_min_value and sum(positions[idx][2] for idx in condition_idx_group) < self.condition_min_value:
+    def _apply_min_value(self, positions, condition_idx_group, benefit_idx_group, result, collect_potential_discounts, subevent_id):
+        if self.condition_min_value and sum(positions[idx].line_price_gross for idx in condition_idx_group) < self.condition_min_value:
             return
 
         if self.condition_min_count or self.benefit_only_apply_to_cheapest_n_matches:
             raise ValueError('Validation invariant violated.')
 
         for idx in benefit_idx_group:
-            previous_price = positions[idx][2]
+            previous_price = positions[idx].line_price_gross
             new_price = round_decimal(
                 previous_price * (Decimal('100.00') - self.benefit_discount_matching_percent) / Decimal('100.00'),
                 self.event.currency,
             )
             result[idx] = new_price
 
-    def _apply_min_count(self, positions, condition_idx_group, benefit_idx_group, result):
+        if collect_potential_discounts is not None:
+            for idx in condition_idx_group:
+                collect_potential_discounts[idx] = [(self, inf, -1, subevent_id)]
+
+    def _apply_min_count(self, positions, condition_idx_group, benefit_idx_group, result, collect_potential_discounts, subevent_id):
         if len(condition_idx_group) < self.condition_min_count:
             return
 
@@ -268,23 +274,53 @@ class Discount(LoggedModel):
             raise ValueError('Validation invariant violated.')
 
         if self.benefit_only_apply_to_cheapest_n_matches:
-            if not self.condition_min_count:
-                raise ValueError('Validation invariant violated.')
-
-            condition_idx_group = sorted(condition_idx_group, key=lambda idx: (positions[idx][2], -idx))  # sort by line_price
-            benefit_idx_group = sorted(benefit_idx_group, key=lambda idx: (positions[idx][2], -idx))  # sort by line_price
+            # sort by line_price
+            condition_idx_group = sorted(condition_idx_group, key=lambda idx: (positions[idx].line_price_gross, -idx))
+            benefit_idx_group = sorted(benefit_idx_group, key=lambda idx: (positions[idx].line_price_gross, -idx))
 
             # Prevent over-consuming of items, i.e. if our discount is "buy 2, get 1 free", we only
             # want to match multiples of 3
-            n_groups = min(len(condition_idx_group) // self.condition_min_count, ceil(len(benefit_idx_group) / self.benefit_only_apply_to_cheapest_n_matches))
+
+            # how many discount applications are allowed according to condition products in cart
+            possible_applications_cond = len(condition_idx_group) // self.condition_min_count
+
+            # how many discount applications are possible according to benefitting products in cart
+            possible_applications_benefit = ceil(len(benefit_idx_group) / self.benefit_only_apply_to_cheapest_n_matches)
+
+            n_groups = min(possible_applications_cond, possible_applications_benefit)
             consume_idx = condition_idx_group[:n_groups * self.condition_min_count]
             benefit_idx = benefit_idx_group[:n_groups * self.benefit_only_apply_to_cheapest_n_matches]
+
+            if collect_potential_discounts is not None:
+                if n_groups * self.benefit_only_apply_to_cheapest_n_matches > len(benefit_idx_group):
+                    # partially used discount ("for each 1 ticket you buy, get 50% on 2 t-shirts", cart content: 1 ticket
+                    # but only 1 t-shirt) -> 1 shirt definitiv potential discount
+                    for idx in consume_idx:
+                        collect_potential_discounts[idx] = [
+                            (self, n_groups * self.benefit_only_apply_to_cheapest_n_matches - len(benefit_idx_group), -1, subevent_id)
+                        ]
+
+                if possible_applications_cond * self.benefit_only_apply_to_cheapest_n_matches > len(benefit_idx_group):
+                    # unused discount ("for each 1 ticket you buy, get 50% on 2 t-shirts", cart content: 1 ticket
+                    # but 0 t-shirts) -> 2 shirt maybe potential discount (if the 1 ticket is not consumed by a later discount)
+                    for i, idx in enumerate(condition_idx_group[
+                                            n_groups * self.condition_min_count:
+                                            possible_applications_cond * self.condition_min_count
+                                            ]):
+                        collect_potential_discounts[idx] += [
+                            (self, self.benefit_only_apply_to_cheapest_n_matches, i // self.condition_min_count, subevent_id)
+                        ]
+
         else:
             consume_idx = condition_idx_group
             benefit_idx = benefit_idx_group
 
+            if collect_potential_discounts is not None:
+                for idx in consume_idx:
+                    collect_potential_discounts[idx] = [(self, inf, -1, subevent_id)]
+
         for idx in benefit_idx:
-            previous_price = positions[idx][2]
+            previous_price = positions[idx].line_price_gross
             new_price = round_decimal(
                 previous_price * (Decimal('100.00') - self.benefit_discount_matching_percent) / Decimal('100.00'),
                 self.event.currency,
@@ -292,15 +328,16 @@ class Discount(LoggedModel):
             result[idx] = new_price
 
         for idx in consume_idx:
-            result.setdefault(idx, positions[idx][2])
+            result.setdefault(idx, positions[idx].line_price_gross)
 
-    def apply(self, positions: Dict[int, Tuple[int, Optional[int], Decimal, bool, Decimal]]) -> Dict[int, Decimal]:
+    def apply(self, positions: Dict[int, PositionInfo],
+              collect_potential_discounts=None) -> Dict[int, Decimal]:
         """
         Tries to apply this discount to a cart
 
-        :param positions: Dictionary mapping IDs to tuples of the form
-                          ``(item_id, subevent_id, line_price_gross, is_addon_to, voucher_discount)``.
+        :param positions: Dictionary mapping IDs to PositionInfo tuples.
                           Bundled positions may not be included.
+        :param collect_potential_discounts: For detailed description, see pretix.base.services.pricing.apply_discounts
 
         :return: A dictionary mapping keys from the input dictionary to new prices. All positions
                  contained in this dictionary are considered "consumed" and should not be considered
@@ -342,13 +379,13 @@ class Discount(LoggedModel):
 
         if self.subevent_mode == self.SUBEVENT_MODE_MIXED:  # also applies to non-series events
             if self.condition_min_count:
-                self._apply_min_count(positions, condition_candidates, benefit_candidates, result)
+                self._apply_min_count(positions, condition_candidates, benefit_candidates, result, collect_potential_discounts, None)
             else:
-                self._apply_min_value(positions, condition_candidates, benefit_candidates, result)
+                self._apply_min_value(positions, condition_candidates, benefit_candidates, result, collect_potential_discounts, None)
 
         elif self.subevent_mode == self.SUBEVENT_MODE_SAME:
             def key(idx):
-                return positions[idx][1] or 0  # subevent_id
+                return positions[idx].subevent_id or 0
 
             # Build groups of candidates with the same subevent, then apply our regular algorithm
             # to each group
@@ -357,11 +394,11 @@ class Discount(LoggedModel):
             candidate_groups = [(k, list(g)) for k, g in _groups]
 
             for subevent_id, g in candidate_groups:
-                benefit_g = [idx for idx in benefit_candidates if positions[idx][1] == subevent_id]
+                benefit_g = [idx for idx in benefit_candidates if positions[idx].subevent_id == subevent_id]
                 if self.condition_min_count:
-                    self._apply_min_count(positions, g, benefit_g, result)
+                    self._apply_min_count(positions, g, benefit_g, result, collect_potential_discounts, subevent_id)
                 else:
-                    self._apply_min_value(positions, g, benefit_g, result)
+                    self._apply_min_value(positions, g, benefit_g, result, collect_potential_discounts, subevent_id)
 
         elif self.subevent_mode == self.SUBEVENT_MODE_DISTINCT:
             if self.condition_min_value or not self.benefit_same_products:
@@ -377,9 +414,9 @@ class Discount(LoggedModel):
             # Build a list of subevent IDs in descending order of frequency
             subevent_to_idx = defaultdict(list)
             for idx, p in positions.items():
-                subevent_to_idx[p[1]].append(idx)
+                subevent_to_idx[p.subevent_id].append(idx)
             for v in subevent_to_idx.values():
-                v.sort(key=lambda idx: positions[idx][2])
+                v.sort(key=lambda idx: positions[idx].line_price_gross)
             subevent_order = sorted(list(subevent_to_idx.keys()), key=lambda s: len(subevent_to_idx[s]), reverse=True)
 
             # Build groups of exactly condition_min_count distinct subevents
@@ -394,7 +431,7 @@ class Discount(LoggedModel):
                     l = [ll for ll in l if ll in condition_candidates and ll not in current_group]
                     if cardinality and len(l) != cardinality:
                         continue
-                    if se not in {positions[idx][1] for idx in current_group}:
+                    if se not in {positions[idx].subevent_id for idx in current_group}:
                         candidates += l
                         cardinality = len(l)
 
@@ -403,7 +440,7 @@ class Discount(LoggedModel):
 
                 # Sort the list by prices, then pick one. For "buy 2 get 1 free" we apply a "pick 1 from the start
                 # and 2 from the end" scheme to optimize price distribution among groups
-                candidates = sorted(candidates, key=lambda idx: positions[idx][2])
+                candidates = sorted(candidates, key=lambda idx: positions[idx].line_price_gross)
                 if len(current_group) < (self.benefit_only_apply_to_cheapest_n_matches or 0):
                     candidate = candidates[0]
                 else:
@@ -415,14 +452,14 @@ class Discount(LoggedModel):
                 if len(current_group) >= max(self.condition_min_count, 1):
                     candidate_groups.append(current_group)
                     for c in current_group:
-                        subevent_to_idx[positions[c][1]].remove(c)
+                        subevent_to_idx[positions[c].subevent_id].remove(c)
                     current_group = []
 
             # Distribute "leftovers"
             for se in subevent_order:
                 if subevent_to_idx[se]:
                     for group in candidate_groups:
-                        if se not in {positions[idx][1] for idx in group}:
+                        if se not in {positions[idx].subevent_id for idx in group}:
                             group.append(subevent_to_idx[se].pop())
                             if not subevent_to_idx[se]:
                                 break
@@ -432,6 +469,8 @@ class Discount(LoggedModel):
                     positions,
                     [idx for idx in g if idx in condition_candidates],
                     [idx for idx in g if idx in benefit_candidates],
-                    result
+                    result,
+                    None,
+                    None
                 )
         return result

src/pretix/base/models/event.py

@@ -870,10 +870,12 @@ class Event(EventMixin, LoggedModel):
         for i in Item.objects.filter(event=other).prefetch_related(
             'variations', 'limit_sales_channels', 'require_membership_types',
             'variations__limit_sales_channels', 'variations__require_membership_types',
+            'matched_by_cross_selling_categories',
         ):
             vars = list(i.variations.all())
             require_membership_types = list(i.require_membership_types.all())
             limit_sales_channels = list(i.limit_sales_channels.all())
+            matched_by_cross_selling_categories = list(i.matched_by_cross_selling_categories.all())
             item_map[i.pk] = i
             i.pk = None
             i.event = self
@@ -911,6 +913,9 @@ class Event(EventMixin, LoggedModel):
                 if not v.all_sales_channels:
                     v.limit_sales_channels.set(self.organizer.sales_channels.filter(identifier__in=[s.identifier for s in limit_sales_channels]))
 
+            if matched_by_cross_selling_categories:
+                i.matched_by_cross_selling_categories.set([category_map[c.pk] for c in matched_by_cross_selling_categories])
+
         for i in self.items.filter(hidden_if_item_available__isnull=False):
             i.hidden_if_item_available = item_map[i.hidden_if_item_available_id]
             i.save()

src/pretix/base/models/items.py

@@ -63,14 +63,13 @@ from django_countries.fields import Country
 from django_scopes import ScopedManager
 from i18nfield.fields import I18nCharField, I18nTextField
 
+from pretix.base.media import MEDIA_TYPES
+from pretix.base.models import Event, SubEvent
 from pretix.base.models.base import LoggedModel
 from pretix.base.models.fields import MultiStringField
 from pretix.base.models.tax import TaxedPrice
 from pretix.base.timemachine import time_machine_now
-
-from ...helpers.images import ImageSizeValidator
-from ..media import MEDIA_TYPES
-from .event import Event, SubEvent
+from pretix.helpers.images import ImageSizeValidator
 
 
 class ItemCategory(LoggedModel):
@@ -111,6 +110,33 @@ class ItemCategory(LoggedModel):
                     'only be bought in combination with a product that has this category configured as a possible '
                     'source for add-ons.')
     )
+    CROSS_SELLING_MODES = (
+        (None, _('Normal category')),
+        ('both', _('Normal + cross-selling category')),
+        ('only', _('Cross-selling category')),
+    )
+    cross_selling_mode = models.CharField(
+        choices=CROSS_SELLING_MODES,
+        null=True,
+        max_length=5
+    )
+    CROSS_SELLING_CONDITION = (
+        ('always', _('Always show in cross-selling step')),
+        ('discounts', _('Only show products that qualify for a discount according to discount rules')),
+        ('products', _('Only show if the cart contains one of the following products')),
+    )
+    cross_selling_condition = models.CharField(
+        verbose_name=_("Cross-selling condition"),
+        choices=CROSS_SELLING_CONDITION,
+        null=True,
+        max_length=10,
+    )
+    cross_selling_match_products = models.ManyToManyField(
+        'pretixbase.Item',
+        blank=True,
+        verbose_name=_("Cross-selling condition products"),
+        related_name="matched_by_cross_selling_categories",
+    )
 
     class Meta:
         verbose_name = _("Product category")
@@ -119,19 +145,31 @@ class ItemCategory(LoggedModel):
 
     def __str__(self):
         name = self.internal_name or self.name
-        if self.is_addon:
-            return _('{category} (Add-On products)').format(category=str(name))
+        category_type = self.get_category_type_display()
+        if category_type:
+            return _('{category} ({category_type})').format(category=str(name), category_type=category_type)
         return str(name)
 
     def get_category_type_display(self):
         if self.is_addon:
-            return _('Add-On products')
+            return _('Add-on category')
+        elif self.cross_selling_mode:
+            return self.get_cross_selling_mode_display()
         else:
             return None
 
     @property
     def category_type(self):
-        return 'addon' if self.is_addon else 'normal'
+        return 'addon' if self.is_addon else self.cross_selling_mode or 'normal'
+
+    @category_type.setter
+    def category_type(self, new_value):
+        if new_value == 'addon':
+            self.is_addon = True
+            self.cross_selling_mode = None
+        else:
+            self.is_addon = False
+            self.cross_selling_mode = None if new_value == 'normal' else new_value
 
     def delete(self, *args, **kwargs):
         super().delete(*args, **kwargs)
@@ -270,7 +308,7 @@ class SubEventItemVariation(models.Model):
         return True
 
 
-def filter_available(qs, channel='web', voucher=None, allow_addons=False):
+def filter_available(qs, channel='web', voucher=None, allow_addons=False, allow_cross_sell=False):
     # Channel can currently be a SalesChannel or a str, since we need that compatibility, but a SalesChannel
     # makes the query SIGNIFICANTLY faster
     from .organizer import SalesChannel
@@ -291,6 +329,8 @@ def filter_available(qs, channel='web', voucher=None, allow_addons=False):
 
     if not allow_addons:
         q &= Q(Q(category__isnull=True) | Q(category__is_addon=False))
+    if not allow_cross_sell:
+        q &= Q(Q(category__isnull=True) | ~Q(category__cross_selling_mode='only'))
 
     if voucher:
         if voucher.item_id:
@@ -304,8 +344,8 @@ def filter_available(qs, channel='web', voucher=None, allow_addons=False):
 
 
 class ItemQuerySet(models.QuerySet):
-    def filter_available(self, channel='web', voucher=None, allow_addons=False):
-        return filter_available(self, channel, voucher, allow_addons)
+    def filter_available(self, channel='web', voucher=None, allow_addons=False, allow_cross_sell=False):
+        return filter_available(self, channel, voucher, allow_addons, allow_cross_sell)
 
 
 class ItemQuerySetManager(ScopedManager(organizer='event__organizer').__class__):
@@ -313,8 +353,8 @@ class ItemQuerySetManager(ScopedManager(organizer='event__organizer').__class__)
         super().__init__()
         self._queryset_class = ItemQuerySet
 
-    def filter_available(self, channel='web', voucher=None, allow_addons=False):
-        return filter_available(self.get_queryset(), channel, voucher, allow_addons)
+    def filter_available(self, channel='web', voucher=None, allow_addons=False, allow_cross_sell=False):
+        return filter_available(self.get_queryset(), channel, voucher, allow_addons, allow_cross_sell)
 
 
 class Item(LoggedModel):

src/pretix/base/services/cart.py

@@ -1542,10 +1542,9 @@ def add_items_to_cart(self, event: int, items: List[dict], cart_id: str=None, lo
 @app.task(base=ProfiledEventTask, bind=True, max_retries=5, default_retry_delay=1, throws=(CartError,))
 def apply_voucher(self, event: Event, voucher: str, cart_id: str=None, locale='en', sales_channel='web', override_now_dt: datetime=None) -> None:
     """
-    Removes a list of items from a user's cart.
     :param event: The event ID in question
     :param voucher: A voucher code
-    :param session: Session ID of a guest
+    :param cart_id: The cart ID of the cart to modify
     """
     with language(locale), time_machine_now_assigned(override_now_dt):
         try:
@@ -1566,10 +1565,10 @@ def apply_voucher(self, event: Event, voucher: str, cart_id: str=None, locale='e
 @app.task(base=ProfiledEventTask, bind=True, max_retries=5, default_retry_delay=1, throws=(CartError,))
 def remove_cart_position(self, event: Event, position: int, cart_id: str=None, locale='en', sales_channel='web', override_now_dt: datetime=None) -> None:
     """
-    Removes a list of items from a user's cart.
+    Removes an item specified by its position ID from a user's cart.
     :param event: The event ID in question
     :param position: A cart position ID
-    :param session: Session ID of a guest
+    :param cart_id: The cart ID of the cart to modify
     """
     with language(locale), time_machine_now_assigned(override_now_dt):
         try:
@@ -1590,9 +1589,9 @@ def remove_cart_position(self, event: Event, position: int, cart_id: str=None, l
 @app.task(base=ProfiledEventTask, bind=True, max_retries=5, default_retry_delay=1, throws=(CartError,))
 def clear_cart(self, event: Event, cart_id: str=None, locale='en', sales_channel='web', override_now_dt: datetime=None) -> None:
     """
-    Removes a list of items from a user's cart.
+    Removes all items from a user's cart.
     :param event: The event ID in question
-    :param session: Session ID of a guest
+    :param cart_id: The cart ID of the cart to modify
     """
     with language(locale), time_machine_now_assigned(override_now_dt):
         try:
@@ -1611,13 +1610,15 @@ def clear_cart(self, event: Event, cart_id: str=None, locale='en', sales_channel
 
 
 @app.task(base=ProfiledEventTask, bind=True, max_retries=5, default_retry_delay=1, throws=(CartError,))
-def set_cart_addons(self, event: Event, addons: List[dict], cart_id: str=None, locale='en',
+def set_cart_addons(self, event: Event, addons: List[dict], add_to_cart_items: List[dict], cart_id: str=None, locale='en',
                     invoice_address: int=None, sales_channel='web', override_now_dt: datetime=None) -> None:
     """
-    Removes a list of items from a user's cart.
+    Assigns addons to eligible products in a user's cart, adding and removing the addon products as necessary to
+    ensure the requested addon state.
     :param event: The event ID in question
     :param addons: A list of dicts with the keys addon_to, item, variation
-    :param session: Session ID of a guest
+    :param add_to_cart_items: A list of dicts with the keys item, variation, count, custom_price, voucher, seat ID
+    :param cart_id: The cart ID of the cart to modify
     """
     with language(locale), time_machine_now_assigned(override_now_dt):
         ia = False
@@ -1635,6 +1636,7 @@ def set_cart_addons(self, event: Event, addons: List[dict], cart_id: str=None, l
             try:
                 cm = CartManager(event=event, cart_id=cart_id, invoice_address=ia, sales_channel=sales_channel)
                 cm.set_addons(addons)
+                cm.add_new_items(add_to_cart_items)
                 cm.commit()
             except LockTimeoutException:
                 self.retry()

src/pretix/base/services/cross_selling.py

@@ -0,0 +1,232 @@
+#
+# This file is part of pretix (Community Edition).
+#
+# Copyright (C) 2014-2020 Raphael Michel and contributors
+# Copyright (C) 2020-2021 rami.io 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/>.
+#
+
+from collections import defaultdict
+from decimal import Decimal
+from itertools import groupby
+from math import inf
+from typing import List
+
+from django.utils.functional import cached_property
+
+from pretix.base.models import CartPosition, ItemCategory, SalesChannel
+from pretix.presale.views.event import get_grouped_items
+
+
+class DummyCategory:
+    """
+    Used to create fake category objects for displaying the same cross-selling category multiple times,
+    once for each subevent
+    """
+
+    def __init__(self, category: ItemCategory, subevent):
+        self.id = category.id
+        self.name = str(category.name)
+        self.subevent_name = str(subevent)
+        self.description = category.description
+
+
+class CrossSellingService:
+    def __init__(self, event, sales_channel: SalesChannel, cartpositions: List[CartPosition], customer):
+        self.event = event
+        self.sales_channel = sales_channel
+        self.cartpositions = cartpositions
+        self.customer = customer
+
+    def get_data(self):
+        if self.event.has_subevents:
+            subevents = set(pos.subevent for pos in self.cartpositions)
+            result = (
+                (DummyCategory(category, subevent),
+                 self._prepare_items(subevent, items_qs, discount_info),
+                 f'subevent_{subevent.pk}_')
+                for subevent in subevents
+                for (category, items_qs, discount_info) in self._applicable_categories(subevent.pk)
+            )
+        else:
+            result = (
+                (category,
+                 self._prepare_items(None, items_qs, discount_info),
+                 '')
+                for (category, items_qs, discount_info) in self._applicable_categories(0)
+            )
+        result = [(category, items, form_prefix) for (category, items, form_prefix) in result if len(items) > 0]
+        for category, items, form_prefix in result:
+            category.category_has_discount = any(item.original_price for item in items)
+        return result
+
+    def _applicable_categories(self, subevent_id):
+        return [
+            (c, products_qs, discount_info) for (c, products_qs, discount_info) in
+            (
+                (c, *self._get_visible_items_for_category(subevent_id, c))
+                for c in self.event.categories.filter(cross_selling_mode__isnull=False).prefetch_related('items')
+            )
+            if products_qs is not None
+        ]
+
+    def _get_visible_items_for_category(self, filter_subevent_id, category: ItemCategory):
+        """
+        If this category should be visible in the cross-selling step for a given cart and sales_channel, this method
+        returns a queryset of the items that should be displayed, as well as a dict giving additional information on them.
+
+        :returns: (QuerySet<Item>, dict<(subevent_id, item_pk): (max_count, discount_rule)>)
+            max_count is `inf` if the item should not be limited
+            discount_rule is None if the item will not be discounted
+        """
+        if category.cross_selling_mode is None:
+            return None, {}
+        if category.cross_selling_condition == 'always':
+            return category.items.all(), {}
+        if category.cross_selling_condition == 'products':
+            match = set(match.pk for match in category.cross_selling_match_products.only('pk'))  # TODO prefetch this
+            return (category.items.all(), {}) if any(pos.item.pk in match for pos in self.cartpositions) else (None, {})
+        if category.cross_selling_condition == 'discounts':
+            my_item_pks = [item.id for item in category.items.all()]
+            potential_discount_items = {
+                item.pk: (max_count, discount_rule)
+                for subevent_id, item, max_count, discount_rule in self._potential_discounts_by_subevent_and_item_for_current_cart
+                if max_count > 0 and item.pk in my_item_pks and item.is_available() and (subevent_id == filter_subevent_id or subevent_id is None)
+            }
+            return category.items.filter(pk__in=potential_discount_items), potential_discount_items
+
+    @cached_property
+    def _potential_discounts_by_subevent_and_item_for_current_cart(self):
+        potential_discounts_by_cartpos = defaultdict(list)
+
+        from ..services.pricing import apply_discounts
+        self._discounted_prices = apply_discounts(
+            self.event,
+            self.sales_channel,
+            [
+                (cp.item_id, cp.subevent_id, cp.line_price_gross, bool(cp.addon_to), cp.is_bundled,
+                 cp.listed_price - cp.price_after_voucher)
+                for cp in self.cartpositions
+            ],
+            collect_potential_discounts=potential_discounts_by_cartpos
+        )
+
+        # flatten potential_discounts_by_cartpos (a dict of lists of potential discounts) into a set of potential discounts
+        # (which is technically stored as a dict, but we use it as an OrderedSet here)
+        potential_discount_set = dict.fromkeys(
+            info for lst in potential_discounts_by_cartpos.values() for info in lst)
+
+        # sum up the max_counts and pass them on (also pass on the discount_rules so we can calculate actual discounted prices later):
+        # group by benefit product
+        # - max_count for product: sum up max_counts
+        # - discount_rule for product: take first discount_rule
+
+        def discount_info(subevent_id, item, infos_for_item):
+            infos_for_item = list(infos_for_item)
+            return (
+                subevent_id,
+                item,
+                sum(max_count for (subevent_id, item, discount_rule, max_count, i) in infos_for_item),
+                next(discount_rule for (subevent_id, item, discount_rule, max_count, i) in infos_for_item),
+            )
+
+        return [
+            discount_info(subevent_id, item, infos_for_item) for (subevent_id, item), infos_for_item in
+            groupby(
+                sorted(
+                    (
+                        (subevent_id, item, discount_rule, max_count, i)
+                        for (discount_rule, max_count, i, subevent_id) in potential_discount_set.keys()
+                        for item in discount_rule.benefit_limit_products.all()
+                    ),
+                    key=lambda tup: (tup[0], tup[1].pk)
+                ),
+                lambda tup: (tup[0], tup[1]))
+        ]
+
+    def _prepare_items(self, subevent, items_qs, discount_info):
+        items, _btn = get_grouped_items(
+            self.event,
+            subevent=subevent,
+            voucher=None,
+            channel=self.sales_channel,
+            base_qs=items_qs,
+            allow_addons=False,
+            allow_cross_sell=True,
+            memberships=(
+                self.customer.usable_memberships(
+                    for_event=subevent or self.event,
+                    testmode=self.event.testmode
+                )
+                if self.customer else None
+            ),
+        )
+        new_items = list()
+        for item in items:
+            max_count = inf
+            if item.pk in discount_info:
+                (max_count, discount_rule) = discount_info[item.pk]
+
+                # only benefit_only_apply_to_cheapest_n_matches discounted items have a max_count, all others get 'inf'
+                if not max_count:
+                    max_count = inf
+
+                # calculate discounted price
+                if discount_rule and discount_rule.benefit_discount_matching_percent > 0:
+                    if not item.has_variations:
+                        item.original_price = item.original_price or item.display_price
+                        previous_price = item.display_price
+                        new_price = (
+                            previous_price * (
+                                (Decimal('100.00') - discount_rule.benefit_discount_matching_percent) / Decimal('100.00'))
+                        )
+                        item.display_price = new_price
+                    else:
+                        # discounts always match "whole" items, not specific variations -> we apply the discount to all
+                        # available variations of the item
+                        for var in item.available_variations:
+                            var.original_price = var.original_price or var.display_price
+                            previous_price = var.display_price
+                            new_price = (
+                                previous_price * (
+                                    (Decimal('100.00') - discount_rule.benefit_discount_matching_percent) / Decimal('100.00'))
+                            )
+                            var.display_price = new_price
+
+            if not item.has_variations:
+                # reduce order_max by number of items already in cart (prevent recommending a product the user can't add anyway)
+                item.order_max = min(
+                    item.order_max - sum(1 for pos in self.cartpositions if pos.item_id == item.pk),
+                    max_count
+                )
+                if item.order_max > 0:
+                    new_items.append(item)
+            else:
+                new_vars = list()
+                for var in item.available_variations:
+                    # reduce order_max by number of items already in cart (prevent recommending a product the user can't add anyway)
+                    var.order_max = min(
+                        var.order_max - sum(1 for pos in self.cartpositions if pos.item_id == item.pk and pos.variation_id == var.pk),
+                        max_count
+                    )
+                    if var.order_max > 0:
+                        new_vars.append(var)
+                if len(new_vars):
+                    item.available_variations = new_vars
+                    new_items.append(item)
+
+        return new_items

src/pretix/base/services/pricing.py

@@ -20,8 +20,9 @@
 # <https://www.gnu.org/licenses/>.
 #
 import re
+from collections import defaultdict
 from decimal import Decimal
-from typing import List, Optional, Tuple
+from typing import List, Optional, Tuple, Union
 
 from django import forms
 from django.db.models import Q
@@ -31,6 +32,7 @@ from pretix.base.models import (
     AbstractPosition, InvoiceAddress, Item, ItemAddOn, ItemVariation,
     SalesChannel, Voucher,
 )
+from pretix.base.models.discount import Discount, PositionInfo
 from pretix.base.models.event import Event, SubEvent
 from pretix.base.models.tax import TAXED_ZERO, TaxedPrice, TaxRule
 from pretix.base.timemachine import time_machine_now
@@ -155,14 +157,22 @@ def get_line_price(price_after_voucher: Decimal, custom_price_input: Decimal, cu
     return price
 
 
-def apply_discounts(event: Event, sales_channel: str,
-                    positions: List[Tuple[int, Optional[int], Decimal, bool, bool]]) -> List[Decimal]:
+def apply_discounts(event: Event, sales_channel: Union[str, SalesChannel],
+                    positions: List[Tuple[int, Optional[int], Decimal, bool, bool, Decimal]],
+                    collect_potential_discounts: Optional[defaultdict]=None) -> List[Tuple[Decimal, Optional[Discount]]]:
     """
     Applies any dynamic discounts to a cart
 
     :param event: Event the cart belongs to
     :param sales_channel: Sales channel the cart was created with
     :param positions: Tuple of the form ``(item_id, subevent_id, line_price_gross, is_addon_to, is_bundled, voucher_discount)``
+    :param collect_potential_discounts: If a `defaultdict(list)` is supplied, all discounts that could be applied to the cart
+    based on the "consumed" items, but lack matching "benefitting" items will be collected therein.
+    The dict will contain a mapping from index in the `positions` list of the item that could be consumed, to a list
+    of tuples describing the discounts that could be applied in the form `(discount, max_count, grouping_id)`.
+    `max_count` is either the maximum number of benefitting items that the discount would apply to, or `inf` if that number
+    is not limited. The `grouping_id` can be used to distinguish several occurrences of the same discount.
+
     :return: A list of ``(new_gross_price, discount)`` tuples in the same order as the input
     """
     if isinstance(sales_channel, SalesChannel):
@@ -177,10 +187,10 @@ def apply_discounts(event: Event, sales_channel: str,
     ).prefetch_related('condition_limit_products', 'benefit_limit_products').order_by('position', 'pk')
     for discount in discount_qs:
         result = discount.apply({
-            idx: (item_id, subevent_id, line_price_gross, is_addon_to, voucher_discount)
+            idx: PositionInfo(item_id, subevent_id, line_price_gross, is_addon_to, voucher_discount)
             for idx, (item_id, subevent_id, line_price_gross, is_addon_to, is_bundled, voucher_discount) in enumerate(positions)
             if not is_bundled and idx not in new_prices
-        })
+        }, collect_potential_discounts)
         for k in result.keys():
             result[k] = (result[k], discount)
         new_prices.update(result)