@stamhoofd/structures 2.85.3 → 2.86.0

package/esm/dist/src/filters/convertOldPropertyFilter.js

@@ -0,0 +1,678 @@
+import { PropertyFilter } from './PropertyFilter.js';
+// todo: remove after migration
+// #region types
+var NumberFilterMode;
+(function (NumberFilterMode) {
+    NumberFilterMode["GreaterThan"] = "GreaterThan";
+    NumberFilterMode["LessThan"] = "LessThan";
+    NumberFilterMode["Between"] = "Between";
+    NumberFilterMode["NotBetween"] = "NotBetween";
+    NumberFilterMode["Equal"] = "Equal";
+    NumberFilterMode["NotEqual"] = "NotEqual";
+})(NumberFilterMode || (NumberFilterMode = {}));
+var StringFilterMode;
+(function (StringFilterMode) {
+    StringFilterMode["Contains"] = "Contains";
+    StringFilterMode["Equals"] = "Equals";
+    StringFilterMode["NotContains"] = "NotContains";
+    StringFilterMode["NotEquals"] = "NotEquals";
+    StringFilterMode["NotEmpty"] = "NotEmpty";
+    StringFilterMode["Empty"] = "Empty";
+})(StringFilterMode || (StringFilterMode = {}));
+var ChoicesFilterMode;
+(function (ChoicesFilterMode) {
+    ChoicesFilterMode["Or"] = "Or";
+    ChoicesFilterMode["And"] = "And";
+    /**
+     * Means !(A || B) == !A && !B
+     */
+    ChoicesFilterMode["Nor"] = "Nor";
+    /**
+     * Means !(A && B) == !A || !B
+     */
+    ChoicesFilterMode["Nand"] = "Nand";
+})(ChoicesFilterMode || (ChoicesFilterMode = {}));
+var DateFilterMode;
+(function (DateFilterMode) {
+    DateFilterMode["GreaterThan"] = "GreaterThan";
+    DateFilterMode["LessThan"] = "LessThan";
+    DateFilterMode["Between"] = "Between";
+    DateFilterMode["NotBetween"] = "NotBetween";
+    DateFilterMode["Equal"] = "Equal";
+    DateFilterMode["NotEqual"] = "NotEqual";
+})(DateFilterMode || (DateFilterMode = {}));
+var GroupFilterMode;
+(function (GroupFilterMode) {
+    GroupFilterMode["Or"] = "Or";
+    GroupFilterMode["And"] = "And";
+    /**
+     * Means !(A || B) == !A && !B
+     */
+    GroupFilterMode["Nor"] = "Nor";
+    /**
+     * Means !(A && B) == !A || !B
+     */
+    GroupFilterMode["Nand"] = "Nand";
+})(GroupFilterMode || (GroupFilterMode = {}));
+var RegistrationsFilterMode;
+(function (RegistrationsFilterMode) {
+    RegistrationsFilterMode["Or"] = "Or";
+    RegistrationsFilterMode["And"] = "And";
+    /**
+     * Means !(A || B) == !A && !B
+     */
+    RegistrationsFilterMode["Nor"] = "Nor";
+    /**
+     * Means !(A && B) == !A || !B
+     */
+    RegistrationsFilterMode["Nand"] = "Nand";
+})(RegistrationsFilterMode || (RegistrationsFilterMode = {}));
+var FilterType;
+(function (FilterType) {
+    FilterType["NumberFilter"] = "NumberFilter";
+    FilterType["StringFilter"] = "StringFilter";
+    FilterType["ChoicesFilter"] = "ChoicesFilter";
+    FilterType["DateFilter"] = "DateFilter";
+    FilterType["FilterGroup"] = "FilterGroup";
+    FilterType["PropertyFilter"] = "PropertyFilter";
+    FilterType["RegistrationsFilter"] = "RegistrationsFilter";
+})(FilterType || (FilterType = {}));
+// #endregion
+function filterToStamhoofdFilter(filter) {
+    const type = getFilterType(filter);
+    switch (type) {
+        case FilterType.NumberFilter:
+            return numberFilterToStamhoofdFilter(filter);
+        case FilterType.StringFilter:
+            return stringFilterToStamhoofdFilter(filter);
+        case FilterType.ChoicesFilter:
+            return choicesFilterToStamhoofdFilter(filter);
+        case FilterType.DateFilter:
+            return dateFilterToStamhoofdFilter(filter);
+        case FilterType.FilterGroup:
+            return filterGroupToStamhoofdFilter(filter);
+        case FilterType.PropertyFilter:
+            throw new Error(`PropertyFilter not implemented: ${JSON.stringify(filter)}`);
+        case FilterType.RegistrationsFilter:
+            return registrationsFilterToStamhoofdFilter(filter);
+    }
+}
+const filterDefinitionIDSQLFilterIdMap = new Map([
+    ['member_age', 'age'],
+    ['member_gender', 'gender'],
+    ['member_birthDay', 'birthDay'],
+    ['gender', 'gender'],
+]);
+function getSQLFilterId(filter) {
+    const definitionId = filter.definitionId;
+    if (!definitionId) {
+        throw new Error('filter has no definitionId');
+    }
+    const result = filterDefinitionIDSQLFilterIdMap.get(definitionId);
+    if (!result) {
+        throw new Error('No sql filter id found for definitionId: ' + definitionId);
+    }
+    return result;
+}
+function numberFilterToStamhoofdFilter(filter) {
+    if (filter.definitionId.startsWith('record_')) {
+        throw new Error(`Number filter not supported: ${filter.definitionId}`);
+    }
+    const supported = new Set(['member_age']);
+    if (!supported.has(filter.definitionId)) {
+        throw new Error(`Number filter not supported: ${filter.definitionId}`);
+    }
+    const sqlFilterId = getSQLFilterId(filter);
+    switch (filter.mode) {
+        case NumberFilterMode.LessThan: {
+            if (filter.end === undefined) {
+                throw new Error('LessThan filter has no end');
+            }
+            return {
+                [sqlFilterId]: {
+                    $lte: filter.end,
+                },
+            };
+        }
+        case NumberFilterMode.GreaterThan: {
+            if (filter.start === undefined) {
+                throw new Error('GreaterThan filter has no start');
+            }
+            return {
+                [sqlFilterId]: {
+                    $gte: filter.start,
+                },
+            };
+        }
+        case NumberFilterMode.Between: {
+            if (filter.start === undefined || filter.end === undefined) {
+                throw new Error('Between filter has no start or end');
+            }
+            return {
+                $and: [
+                    { [sqlFilterId]: {
+                            $gte: filter.start,
+                        } },
+                    { [sqlFilterId]: {
+                            $lte: filter.end,
+                        } },
+                ],
+            };
+        }
+        case NumberFilterMode.NotBetween: {
+            if (filter.start === undefined || filter.end === undefined) {
+                throw new Error('NotBetween filter has no start or end');
+            }
+            return {
+                $or: [
+                    { [sqlFilterId]: {
+                            $lt: filter.start,
+                        } },
+                    { [sqlFilterId]: {
+                            $gt: filter.end,
+                        } },
+                ],
+            };
+        }
+        case NumberFilterMode.Equal: {
+            if (filter.start === undefined) {
+                throw new Error('Equal filter has no value: ' + JSON.stringify(filter));
+            }
+            return {
+                [sqlFilterId]: {
+                    $eq: filter.start,
+                },
+            };
+        }
+        case NumberFilterMode.NotEqual: {
+            if (filter.start === undefined) {
+                throw new Error('Not equal filter has no value');
+            }
+            return {
+                [sqlFilterId]: {
+                    $neq: filter.start,
+                },
+            };
+        }
+    }
+}
+function stringFilterToStamhoofdFilter(filter) {
+    if (filter.definitionId.startsWith('record_')) {
+        const recordId = filter.definitionId.replace('record_', '');
+        return {
+            recordAnswers: {
+                [recordId]: {
+                    value: { $eq: filter.value },
+                },
+            },
+        };
+    }
+    const supported = new Set(['member_name']);
+    if (!supported.has(filter.definitionId)) {
+        throw new Error(`String filter not supported: ${filter.definitionId}`);
+    }
+    const sqlFilterId = getSQLFilterId(filter);
+    switch (filter.mode) {
+        case StringFilterMode.Contains: {
+            return {
+                [sqlFilterId]: {
+                    $contains: filter.value,
+                },
+            };
+        }
+        case StringFilterMode.NotContains: {
+            return {
+                $not: {
+                    [sqlFilterId]: {
+                        $contains: filter.value,
+                    },
+                },
+            };
+        }
+        case StringFilterMode.Empty: {
+            return {
+                $or: [
+                    {
+                        [sqlFilterId]: {
+                            $eq: '',
+                        },
+                    },
+                    {
+                        [sqlFilterId]: {
+                            $eq: null,
+                        },
+                    },
+                ],
+            };
+        }
+        case StringFilterMode.NotEmpty: {
+            return {
+                $not: {
+                    $or: [
+                        {
+                            [sqlFilterId]: {
+                                $eq: '',
+                            },
+                        },
+                        {
+                            [sqlFilterId]: {
+                                $eq: null,
+                            },
+                        },
+                    ],
+                },
+            };
+        }
+        case StringFilterMode.Equals: {
+            return {
+                [sqlFilterId]: {
+                    $eq: filter.value,
+                },
+            };
+        }
+        case StringFilterMode.NotEquals: {
+            return {
+                $not: {
+                    [sqlFilterId]: {
+                        $eq: filter.value,
+                    },
+                },
+            };
+        }
+    }
+}
+function choicesFilterToStamhoofdFilter(filter) {
+    if (filter.definitionId.startsWith('record_')) {
+        const choiceIds = filter.choiceIds;
+        const isCheckbox = choiceIds.includes('checked') || choiceIds.includes('not_checked');
+        const recordId = filter.definitionId.replace('record_', '');
+        if (isCheckbox) {
+            if (filter.mode !== ChoicesFilterMode.Or) {
+                throw new Error(`Unsupported checkbox filter mode: ${filter.mode}`);
+            }
+            return {
+                recordAnswers: {
+                    [recordId]: {
+                        selected: { $in: filter.choiceIds.map(choiceId => choiceId === 'checked') },
+                    },
+                },
+            };
+        }
+        switch (filter.mode) {
+            case ChoicesFilterMode.Or: {
+                return {
+                    recordAnswers: {
+                        [recordId]: {
+                            selectedChoices: {
+                                $elemMatch: {
+                                    id: {
+                                        $in: choiceIds,
+                                    },
+                                },
+                            },
+                        },
+                    },
+                };
+            }
+            case ChoicesFilterMode.And: {
+                // todo: test
+                return {
+                    recordAnswers: {
+                        [recordId]: {
+                            $and: choiceIds.map((choiceId) => {
+                                return {
+                                    selectedChoices: {
+                                        $elemMatch: {
+                                            id: {
+                                                $eq: choiceId,
+                                            },
+                                        },
+                                    },
+                                };
+                            }),
+                        },
+                    },
+                };
+            }
+            default: {
+                throw new Error(`Unsupported filter mode for record answers: ${filter.mode}`);
+            }
+        }
+    }
+    const supported = new Set(['member_gender', 'gender', 'member_missing_data']);
+    if (!supported.has(filter.definitionId)) {
+        throw new Error(`Choices filter not supported: ${filter.definitionId}`);
+    }
+    if (filter.definitionId === 'member_missing_data') {
+        const mappedChoiceIds = filter.choiceIds.map((choiceId) => {
+            if (choiceId === 'emergencyContact') {
+                return 'emergencyContacts';
+            }
+            return choiceId;
+        });
+        if (filter.mode === ChoicesFilterMode.Or) {
+            return {
+                missingData: {
+                    $elemMatch: {
+                        $in: mappedChoiceIds,
+                    },
+                },
+            };
+        }
+        if (filter.mode === ChoicesFilterMode.Nor) {
+            return {
+                $not: {
+                    missingData: {
+                        $elemMatch: {
+                            $in: mappedChoiceIds,
+                        },
+                    },
+                },
+            };
+        }
+        const filters = mappedChoiceIds.map((choiceId) => {
+            return {
+                missingData: {
+                    $elemMatch: {
+                        $in: [choiceId],
+                    },
+                },
+            };
+        });
+        switch (filter.mode) {
+            case ChoicesFilterMode.And: {
+                return {
+                    $and: filters,
+                };
+            }
+            case ChoicesFilterMode.Nand: {
+                return {
+                    $not: {
+                        $and: filters,
+                    },
+                };
+            }
+        }
+    }
+    const sqlFilterId = getSQLFilterId(filter);
+    switch (filter.mode) {
+        case ChoicesFilterMode.Or: {
+            return {
+                [sqlFilterId]: {
+                    $in: filter.choiceIds,
+                },
+            };
+        }
+        case ChoicesFilterMode.And: {
+            throw new Error('And mode not supported for choices filter');
+        }
+        case ChoicesFilterMode.Nor: {
+            return {
+                $not: {
+                    [sqlFilterId]: {
+                        $in: filter.choiceIds,
+                    },
+                },
+            };
+        }
+        case ChoicesFilterMode.Nand:
+            throw new Error('Nand mode not supported for choices filter');
+    }
+}
+function dateFilterToStamhoofdFilter(filter) {
+    if (filter.definitionId.startsWith('record_')) {
+        throw new Error(`Date filter not supported: ${filter.definitionId}`);
+    }
+    const supported = new Set(['member_birthDay']);
+    if (!supported.has(filter.definitionId)) {
+        throw new Error(`Date filter not supported: ${filter.definitionId}`);
+    }
+    const sqlFilterId = getSQLFilterId(filter);
+    function msToFilterValue(ms) {
+        return { $: '$date', value: ms };
+    }
+    if (filter.minimumDate) {
+        return {
+            [sqlFilterId]: {
+                $gte: filter.minimumDate,
+            },
+        };
+    }
+    switch (filter.mode) {
+        case DateFilterMode.GreaterThan: {
+            if (filter.minimumDate === undefined) {
+                throw new Error('GreaterThan filter has no minimumDate');
+            }
+            return {
+                [sqlFilterId]: {
+                    $gte: msToFilterValue(filter.minimumDate),
+                },
+            };
+        }
+        case DateFilterMode.LessThan: {
+            if (filter.maximumDate === undefined) {
+                throw new Error('LessThan filter has no maximumDate');
+            }
+            return {
+                [sqlFilterId]: {
+                    $lte: msToFilterValue(filter.maximumDate),
+                },
+            };
+        }
+        case DateFilterMode.Between: {
+            if (!filter.minimumDate || !filter.maximumDate) {
+                throw new Error('Between filter has no minimumDate or maximumDate');
+            }
+            return {
+                $and: [
+                    {
+                        [sqlFilterId]: {
+                            $gte: msToFilterValue(filter.minimumDate),
+                        },
+                    },
+                    {
+                        [sqlFilterId]: {
+                            $lte: msToFilterValue(filter.maximumDate),
+                        },
+                    },
+                ],
+            };
+        }
+        case DateFilterMode.NotBetween: {
+            if (!filter.minimumDate || !filter.maximumDate) {
+                throw new Error('NotBetween filter has no minimumDate or maximumDate');
+            }
+            return {
+                $or: [
+                    {
+                        [sqlFilterId]: {
+                            $lt: msToFilterValue(filter.minimumDate),
+                        },
+                    },
+                    {
+                        [sqlFilterId]: {
+                            $gt: msToFilterValue(filter.maximumDate),
+                        },
+                    },
+                ],
+            };
+        }
+        case DateFilterMode.Equal: {
+            if (filter.minimumDate === undefined) {
+                throw new Error('Equal filter has no minimumDate');
+            }
+            return {
+                [sqlFilterId]: {
+                    $eq: msToFilterValue(filter.minimumDate),
+                },
+            };
+        }
+        case DateFilterMode.NotEqual: {
+            if (filter.minimumDate === undefined) {
+                throw new Error('NotEqual filter has no minimumDate');
+            }
+            return {
+                $not: {
+                    [sqlFilterId]: {
+                        $eq: msToFilterValue(filter.minimumDate),
+                    },
+                },
+            };
+        }
+    }
+}
+function getFilterType(filter) {
+    if ('enabledWhen' in filter) {
+        return FilterType.PropertyFilter;
+    }
+    if ('minimumDate' in filter || 'maximumDate' in filter) {
+        return FilterType.DateFilter;
+    }
+    if ('choiceIds' in filter) {
+        return FilterType.ChoicesFilter;
+    }
+    if ('filters' in filter) {
+        return FilterType.FilterGroup;
+    }
+    if ('choices' in filter) {
+        return FilterType.RegistrationsFilter;
+    }
+    if ('value' in filter) {
+        return FilterType.StringFilter;
+    }
+    return FilterType.NumberFilter;
+}
+function filterGroupToStamhoofdFilter(filter) {
+    const filters = filter.filters.map(f => filterToStamhoofdFilter(f));
+    if (filters.length === 0) {
+        console.error('filterGroupToStamhoofdFilter: no filters');
+        return null;
+    }
+    if (filters.length === 1) {
+        const singleFilter = filters[0];
+        switch (filter.mode) {
+            case GroupFilterMode.And:
+                return singleFilter;
+            case GroupFilterMode.Or:
+                return singleFilter;
+            case GroupFilterMode.Nand:
+                return {
+                    $not: singleFilter,
+                };
+            case GroupFilterMode.Nor:
+                return {
+                    $not: singleFilter,
+                };
+        }
+    }
+    switch (filter.mode) {
+        case GroupFilterMode.And:
+            return {
+                $and: filters,
+            };
+        case GroupFilterMode.Or:
+            return {
+                $or: filters,
+            };
+        case GroupFilterMode.Nand:
+            return {
+                $not: {
+                    $and: filters,
+                },
+            };
+        case GroupFilterMode.Nor:
+            return {
+                $not: {
+                    $or: filters,
+                },
+            };
+    }
+}
+export function convertOldPropertyFilter(filter) {
+    let newEnabledWhen = null;
+    let newRequiredWhen = {};
+    if (filter.enabledWhen && filter.enabledWhen.data && filter.enabledWhen.data.filters.length !== 0) {
+        newEnabledWhen = filterToStamhoofdFilter(filter.enabledWhen.data);
+    }
+    if (filter.requiredWhen === null) {
+        newRequiredWhen = null;
+    }
+    else if (filter.requiredWhen.data && filter.requiredWhen.data.filters.length !== 0) {
+        newRequiredWhen = filterToStamhoofdFilter(filter.requiredWhen.data);
+    }
+    return new PropertyFilter(newEnabledWhen, newRequiredWhen);
+}
+function registrationsFilterToStamhoofdFilter(filter) {
+    if (filter.definitionId !== 'registrations') {
+        throw new Error(`Unknown filter definitionId for registrationsFilter: ${filter.definitionId}`);
+    }
+    // todo: ids should be converted in migration for groups?
+    const mode = filter.mode;
+    switch (mode) {
+        case RegistrationsFilterMode.Or: {
+            return {
+                registrations: {
+                    $elemMatch: {
+                        $or: filter.choices.map((c) => {
+                            return {
+                                $groupId: {
+                                    $eq: c.id,
+                                },
+                            };
+                        }),
+                    },
+                },
+            };
+        }
+        case RegistrationsFilterMode.And: {
+            return {
+                registrations: {
+                    $elemMatch: {
+                        $and: filter.choices.map((c) => {
+                            return {
+                                $groupId: {
+                                    $eq: c.id,
+                                },
+                            };
+                        }),
+                    },
+                },
+            };
+        }
+        case RegistrationsFilterMode.Nor: {
+            return {
+                registrations: {
+                    $not: {
+                        $elemMatch: {
+                            $or: filter.choices.map((c) => {
+                                return {
+                                    $groupId: {
+                                        $eq: c.id,
+                                    },
+                                };
+                            }),
+                        },
+                    },
+                },
+            };
+        }
+        case RegistrationsFilterMode.Nand: {
+            return {
+                registrations: {
+                    $not: {
+                        $elemMatch: {
+                            $and: filter.choices.map((c) => {
+                                return {
+                                    $groupId: {
+                                        $eq: c.id,
+                                    },
+                                };
+                            }),
+                        },
+                    },
+                },
+            };
+        }
+    }
+}
+//# sourceMappingURL=convertOldPropertyFilter.js.map