Check-in rules: Make logic results understandable (#2050)

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

src/pretix/helpers/jsonlogic_boolalg.py

@@ -0,0 +1,90 @@
+#
+# 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/>.
+#
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+def convert_to_dnf(rules):
+    """
+    Converts a set of rules to disjunctive normal form, i.e. returns something of the form
+    `(a AND b AND c) OR (a AND d AND f)`
+    without further nesting.
+    """
+    if not isinstance(rules, dict):
+        return rules
+
+    def _distribute_or_over_and(r):
+        operator = list(r.keys())[0]
+        values = rules[operator]
+        if operator == "and":
+            arg_to_distribute = [arg for arg in values if isinstance(arg, dict) and "or" in arg]
+            if not arg_to_distribute:
+                return rules
+            arg_to_distribute = arg_to_distribute[0]
+            other_args = [arg for arg in values if arg is not arg_to_distribute]
+            return {
+                "or": [
+                    {"and": [*other_args, dval]} for dval in arg_to_distribute["or"]
+                ]
+            }
+        elif operator in ("!", "!!", "?:", "if"):
+            raise ValueError(f"Operator {operator} currently unsupported by convert_to_dnf")
+        else:
+            return r
+
+    def _simplify_chained_operators(r):
+        # Simplify `(a OR b) OR (c or d)` to `a OR b OR c OR d` and the same with `AND`
+        if not isinstance(r, dict):
+            return r
+        operator = list(r.keys())[0]
+        values = rules[operator]
+        if operator not in ("or", "and"):
+            return r
+        new_values = []
+        for v in values:
+            if not isinstance(v, dict) or operator not in v:
+                new_values.append(v)
+            else:
+                new_values += v[operator]
+        return {operator: new_values}
+
+    # Run _distribute_or_over_and on until it no longer changes anything. Do so recursively
+    # for the full expression tree.
+    old_rules = rules
+    while True:
+        rules = _distribute_or_over_and(rules)
+        operator = list(rules.keys())[0]
+        values = rules[operator]
+        if not isinstance(values, list):
+            values = [values]
+        rules = {
+            operator: [
+                convert_to_dnf(v) for v in values
+            ] if len(values) > 1 else convert_to_dnf(values[0])
+        }
+        if old_rules == rules:
+            break
+        old_rules = rules
+    # Simplify leftovers of the recursion
+    rules = _simplify_chained_operators(rules)
+    return rules