forked from CGM_Public/pretix_original
93 lines
3.5 KiB
Python
93 lines
3.5 KiB
Python
#
|
|
# 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 = r[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 = r[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]
|
|
no_list = False
|
|
if not isinstance(values, list):
|
|
values = [values]
|
|
no_list = True
|
|
rules = {
|
|
operator: [
|
|
convert_to_dnf(v) for v in values
|
|
] if not no_list 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
|