pne-ui 4.0.8 → 4.0.9

package/esm/src/component/search-ui/filters/state/actions.js

@@ -0,0 +1,1047 @@
+import { exhaustiveCheck, } from '../../../..';
+import { CriterionTypeEnum, ExactCriterionSearchLabelEnum, LinkedEntityTypeEnum, MultichoiceFilterTypeEnum, ThreeDCriterionEnum, } from '../types';
+import { getCriteriaWithAvailabilityRules, isCriterionAvailable, } from '../criterionAvailability';
+import { getSearchUIInitialGrouping, getSearchUIInitialProjectCurrency, getSearchUIInitialSearchCriteria, searchUICountriesInitialAllableCollection, searchUIInitialAllableCollection, searchUIInitialDateFrom, searchUIInitialDateTo, } from './initial';
+// import {raiseUIError} from '../../../../../error';
+import dayjs from 'dayjs';
+import utc from 'dayjs/plugin/utc';
+import timezone from 'dayjs/plugin/timezone';
+import isoWeek from 'dayjs/plugin/isoWeek';
+import cloneDeep from 'lodash/cloneDeep';
+import isEqual from 'lodash/isEqual';
+dayjs.extend(utc);
+dayjs.extend(timezone);
+dayjs.extend(isoWeek);
+const LAST_TEMPLATE_NAME = 'last_template_name';
+const criterionToLinkedEntityMap = {
+    [CriterionTypeEnum.ENDPOINT]: LinkedEntityTypeEnum.ENDPOINT,
+    [CriterionTypeEnum.PROJECT]: LinkedEntityTypeEnum.PROJECT,
+    [CriterionTypeEnum.COMPANY]: LinkedEntityTypeEnum.COMPANY,
+    [CriterionTypeEnum.GATE]: LinkedEntityTypeEnum.GATE,
+    [CriterionTypeEnum.DEALER]: LinkedEntityTypeEnum.DEALER,
+    [CriterionTypeEnum.MANAGER]: LinkedEntityTypeEnum.MANAGER,
+    [CriterionTypeEnum.MERCHANT]: LinkedEntityTypeEnum.MERCHANT,
+    [CriterionTypeEnum.PROCESSOR]: LinkedEntityTypeEnum.PROCESSOR,
+    [CriterionTypeEnum.RESELLER]: LinkedEntityTypeEnum.RESELLER,
+};
+const getLinkedEntityTypeByCriterion = (criterion) => {
+    return criterionToLinkedEntityMap[criterion] ?? null;
+};
+const sanitizeMultigetCriteria = (incoming, activeCriteria) => {
+    if (!incoming.length) {
+        return [];
+    }
+    const allowedEntityTypes = new Set(activeCriteria
+        .map(getLinkedEntityTypeByCriterion)
+        .filter((entityType) => entityType !== null));
+    if (!allowedEntityTypes.size) {
+        return [];
+    }
+    const uniqueByEntity = new Map();
+    incoming.forEach(multigetCriterion => {
+        if (!allowedEntityTypes.has(multigetCriterion.entityType)) {
+            return;
+        }
+        if (!uniqueByEntity.has(multigetCriterion.entityType)) {
+            uniqueByEntity.set(multigetCriterion.entityType, multigetCriterion);
+        }
+    });
+    return Array.from(uniqueByEntity.values());
+};
+const getInitialMultigetCriterion = (entityType) => ({
+    entityType: entityType,
+    filterType: MultichoiceFilterTypeEnum.NONE,
+    searchString: '',
+    selectedItems: '',
+    selectedItemNames: '',
+    deselectedItems: '',
+    deselectedItemNames: '',
+});
+export const getSearchUIFiltersActions = (set, get) => ({
+    setInitialState: (state) => {
+        set((draft) => {
+            return {
+                ...draft,
+                ...state,
+            };
+        });
+        postUpdate(set, get);
+    },
+    updateConditions: (conditions, options) => {
+        set((draft) => {
+            const { criteria: incomingCriteria, multigetCriteria: incomingMultigetCriteria, ...rest } = conditions;
+            const prevCriteria = draft.criteria.slice();
+            Object.assign(draft, rest);
+            if (incomingCriteria !== undefined) {
+                const allowedCriteria = new Set([
+                    ...draft.predefinedCriteria,
+                    ...draft.possibleCriteria,
+                ]);
+                const sanitizedIncoming = Array.from(new Set(incomingCriteria.filter(criterion => allowedCriteria.has(criterion))));
+                const mergedCriteria = Array.from(new Set([
+                    ...draft.predefinedCriteria,
+                    ...sanitizedIncoming,
+                ]));
+                const removedCriteria = prevCriteria.filter(criterion => !mergedCriteria.includes(criterion));
+                removedCriteria.forEach(criterion => {
+                    clearCriterionReducer(draft, criterion);
+                });
+                const addedCriteria = mergedCriteria.filter(criterion => !prevCriteria.includes(criterion));
+                if (incomingMultigetCriteria === undefined) {
+                    addedCriteria.forEach(criterion => {
+                        addInitialMultigetCriterionReducer(draft, criterion);
+                    });
+                }
+                draft.criteria = mergedCriteria;
+            }
+            if (incomingMultigetCriteria !== undefined) {
+                const sanitizedMultigetCriteria = sanitizeMultigetCriteria(incomingMultigetCriteria, draft.criteria);
+                const missingEntityTypes = draft.criteria
+                    .map(getLinkedEntityTypeByCriterion)
+                    .filter((entityType) => entityType !== null)
+                    .filter(entityType => !sanitizedMultigetCriteria.some(item => item.entityType === entityType));
+                missingEntityTypes.forEach(entityType => {
+                    sanitizedMultigetCriteria.push(getInitialMultigetCriterion(entityType));
+                });
+                draft.multigetCriteria = sanitizedMultigetCriteria;
+            }
+            if (options?.resetTemplate) {
+                draft.template = null;
+            }
+        });
+        postUpdate(set, get, options);
+    },
+    restoreClearCriteriaSnapshot: snapshot => {
+        const restoredSnapshot = cloneDeep(snapshot);
+        const { template, hasUnappliedFilters, ...conditions } = restoredSnapshot;
+        if (template?.name) {
+            localStorage.setItem(LAST_TEMPLATE_NAME + get().settingsContextName, template.name);
+        }
+        else {
+            localStorage.removeItem(LAST_TEMPLATE_NAME + get().settingsContextName);
+        }
+        set(draft => {
+            Object.assign(draft, conditions);
+            draft.template = template;
+        });
+        syncCriterionAvailability(set, get);
+        const currentSearchCriteria = extractSearchCriteriaFromState(get());
+        if (!hasUnappliedFilters) {
+            get().onFiltersUpdate(currentSearchCriteria);
+        }
+        set(draft => {
+            draft.prevSearchCriteria = currentSearchCriteria;
+            draft.hasUnappliedFilters = hasUnappliedFilters;
+        });
+    },
+    clearCriteria: () => {
+        localStorage.removeItem(LAST_TEMPLATE_NAME + get().settingsContextName);
+        set((draft) => {
+            return {
+                ...draft,
+                ...getSearchUIInitialSearchCriteria(draft.defaults),
+                exactSearchLabel: draft.exactSearchLabels[0],
+                template: null,
+                criteria: draft.predefinedCriteria,
+            };
+        });
+        postUpdate(set, get);
+    },
+    clearCriterion: (criterionType) => {
+        set((draft) => {
+            clearCriterionReducer(draft, criterionType);
+            addInitialMultigetCriterionReducer(draft, criterionType);
+        });
+        postUpdate(set, get);
+    },
+    addCriterion: (criterionType) => {
+        set((draft) => {
+            draft.criteria.push(criterionType);
+            addInitialMultigetCriterionReducer(draft, criterionType);
+        });
+        get().setJustAddedCriterion(criterionType);
+        postUpdate(set, get);
+    },
+    removeCriterion: (criterionType) => {
+        set((draft) => {
+            clearCriterionReducer(draft, criterionType);
+            const index = draft.criteria.findIndex(c => c === criterionType);
+            draft.criteria.splice(index, 1);
+        });
+        postUpdate(set, get);
+    },
+    createTemplate: (templateName) => {
+        const template = getTemplate(templateName, get());
+        get().defaults.saveSearchTemplate({
+            contextName: get().settingsContextName,
+            template: template,
+            templateName: templateName,
+        })
+            .then(() => {
+            localStorage.setItem(LAST_TEMPLATE_NAME + get().settingsContextName, template.name);
+            set((draft) => {
+                draft.templates.push(template);
+                draft.template = template;
+            });
+        })
+            // .catch(raiseUIError)
+            .catch(console.error);
+    },
+    updateTemplate: (templateName) => {
+        const template = getTemplate(templateName, get());
+        get().defaults.saveSearchTemplate({
+            contextName: get().settingsContextName,
+            template: template,
+            templateName: templateName,
+        })
+            .then(() => {
+            set((draft) => {
+                const index = draft.templates.findIndex(t => t.name === templateName);
+                draft.templates[index].searchConditions = template.searchConditions;
+                draft.template = template;
+            });
+        })
+            // .catch(raiseUIError)
+            .catch(console.error);
+    },
+    removeTemplate: (template) => {
+        get().defaults.deleteSearchTemplate({
+            contextName: get().settingsContextName,
+            templateName: template.name,
+        })
+            .then(() => {
+            const lastTemplateName = localStorage.getItem(LAST_TEMPLATE_NAME + get().settingsContextName);
+            if (lastTemplateName && lastTemplateName === template.name) {
+                localStorage.removeItem(LAST_TEMPLATE_NAME + get().settingsContextName);
+            }
+            set((draft) => {
+                const index = draft.templates.findIndex(t => t.name === template.name);
+                draft.templates.splice(index, 1);
+                if (draft.template?.name === template.name) {
+                    Object.assign(draft, getSearchUIInitialSearchCriteria(draft.defaults));
+                    draft.template = null;
+                    draft.criteria = draft.predefinedCriteria;
+                }
+            });
+            postUpdate(set, get);
+        })
+            // .catch(raiseUIError)
+            .catch(console.error);
+    },
+    setTemplate: (template, options) => {
+        const defaults = getSearchUIInitialSearchCriteria(get().defaults);
+        const conditions = { ...defaults, ...template.searchConditions };
+        if (conditions.dateRangeSpec.dateRangeSpecType !== 'EXACTLY') {
+            conditions.dateRangeSpec = calculateNonExactDates(conditions.dateRangeSpec);
+        }
+        localStorage.setItem(LAST_TEMPLATE_NAME + get().settingsContextName, template.name);
+        set((draft) => {
+            return {
+                ...draft,
+                template: template,
+                ...conditions,
+            };
+        });
+        postUpdate(set, get, options);
+    },
+    loadTemplates: () => {
+        get().defaults.getSearchTemplates(get().settingsContextName)
+            .then(templates => {
+            set((draft) => {
+                draft.templates = templates;
+            });
+            const lastTemplateName = localStorage.getItem(LAST_TEMPLATE_NAME + get().settingsContextName);
+            const lastTemplate = templates.find(t => t.name === lastTemplateName);
+            if (lastTemplate) {
+                get().setTemplate(lastTemplate, { forceSearch: true });
+            }
+        })
+            // .catch(raiseUIError)
+            .catch(console.error);
+    },
+    setJustAddedCriterion: (criterionType) => {
+        set((draft) => {
+            draft.justAddedCriterion = criterionType;
+        });
+    },
+    setMultigetCriterion: (criterion) => {
+        set((draft) => {
+            const index = draft.multigetCriteria.findIndex(c => c.entityType === criterion.entityType);
+            draft.multigetCriteria[index] = criterion;
+        });
+        postUpdate(set, get);
+    },
+    set3DCriterion: (threeD) => {
+        set((draft) => {
+            draft.threeD = threeD;
+        });
+        postUpdate(set, get);
+    },
+    setStatusCriterion: (status) => {
+        set((draft) => {
+            draft.status = status;
+        });
+        postUpdate(set, get);
+    },
+    setExactCriterionSearchLabel: (searchLabel) => {
+        set((draft) => {
+            draft.exactSearchLabel = searchLabel;
+        });
+        postUpdate(set, get);
+    },
+    setExactCriterionSearchValue: (searchValue) => {
+        set((draft) => {
+            draft.exactSearchValue = searchValue;
+        });
+        postUpdate(set, get);
+    },
+    setOrderSearchCriterionLabel: searchLabel => {
+        const oldLabel = get().ordersSearchLabel;
+        set((draft) => {
+            draft.ordersSearchLabel = searchLabel;
+        });
+        // если выбран новый по типу search label, то сбрасываем значение
+        if (OrdersSearchLabelsConfig[oldLabel].type !== OrdersSearchLabelsConfig[searchLabel].type) {
+            set((draft) => {
+                draft.ordersSearchValue = '';
+            });
+        }
+        postUpdate(set, get);
+    },
+    setOrderSearchCriterionValue: searchValue => {
+        set((draft) => {
+            draft.ordersSearchValue = searchValue;
+        });
+        postUpdate(set, get);
+    },
+    setCurrenciesCriterion: (currencies) => {
+        set((draft) => {
+            draft.currencies = currencies;
+        });
+        postUpdate(set, get);
+    },
+    setCountriesCriterion: (countries) => {
+        set((draft) => {
+            draft.countries = countries;
+        });
+        postUpdate(set, get);
+    },
+    setDateRangeCriterionOrderDateType: orderDateType => {
+        set((draft) => {
+            draft.orderDateType = orderDateType;
+        });
+        postUpdate(set, get);
+    },
+    setDateRangeCriterion: (dateRangeSpec) => {
+        const prevDateRangeSpec = get().dateRangeSpec;
+        const prevDateRangeSpecType = prevDateRangeSpec.dateRangeSpecType;
+        const timeSelectionEnabled = get().criteria.includes(CriterionTypeEnum.DATE_RANGE_ORDERS)
+            || !!get().config?.dateRange?.enableTimeSelection;
+        const switchingToExact = dateRangeSpec.dateRangeSpecType === 'EXACTLY'
+            && prevDateRangeSpecType !== 'EXACTLY'
+            && timeSelectionEnabled
+            && prevDateRangeSpec.dateFrom === dateRangeSpec.dateFrom
+            && prevDateRangeSpec.dateTo === dateRangeSpec.dateTo;
+        let spec = dateRangeSpec;
+        if (switchingToExact) {
+            const now = dayjs();
+            spec = {
+                ...spec,
+                dateFrom: now.startOf('day').toDate(),
+                dateTo: now.toDate(),
+            };
+        }
+        else if (dateRangeSpec.dateRangeSpecType !== 'EXACTLY') {
+            spec = calculateNonExactDates(dateRangeSpec);
+        }
+        set((draft) => {
+            draft.dateRangeSpec = spec;
+        });
+        postUpdate(set, get);
+    },
+    setProjectCurrencyCriterionCurrency: (currency) => {
+        set((draft) => {
+            draft.projectCurrency.currency = currency;
+        });
+        postUpdate(set, get);
+    },
+    setProjectCurrencyCriterionConvertFlag: (convertToUserCurrency) => {
+        set((draft) => {
+            draft.projectCurrency.convertToUserCurrency = convertToUserCurrency;
+        });
+        postUpdate(set, get);
+    },
+    setCardTypesCriterion: (cardTypes) => {
+        set((draft) => {
+            draft.cardTypes = cardTypes;
+        });
+        postUpdate(set, get);
+    },
+    setTransactionTypesCriterion: (transactionTypes) => {
+        set((draft) => {
+            draft.transactionTypes = transactionTypes;
+        });
+        postUpdate(set, get);
+    },
+    setTransactionStatusesCriterion: (transactionStatuses) => {
+        set((draft) => {
+            draft.transactionStatuses = transactionStatuses;
+        });
+        postUpdate(set, get);
+    },
+    setTransactionSessionStatusGroupCriterion: (transactionSessionStatusGroup) => {
+        set((draft) => {
+            draft.transactionSessionStatusGroup = transactionSessionStatusGroup;
+        });
+        postUpdate(set, get);
+    },
+    setTransactionSessionStatusesCriterion: (transactionSessionStatuses) => {
+        set((draft) => {
+            draft.transactionSessionStatuses = transactionSessionStatuses;
+        });
+        postUpdate(set, get);
+    },
+    setGroupingCriterionDateType: (dateType) => {
+        set((draft) => {
+            draft.grouping.dateType = dateType;
+        });
+        postUpdate(set, get);
+    },
+    setGroupingCriterionGroups: (available, selected) => {
+        set((draft) => {
+            draft.grouping.availableGroupingTypes = available;
+            draft.grouping.selectedGroupingTypes = selected;
+        });
+        postUpdate(set, get);
+    },
+    setRecurrenceTypesCriterion: (recurrenceTypes) => {
+        set((draft) => {
+            draft.recurrenceTypes = recurrenceTypes;
+        });
+        postUpdate(set, get);
+    },
+    setRecurrenceStatusesCriterion: (recurrenceStatuses) => {
+        set((draft) => {
+            draft.recurrenceStatuses = recurrenceStatuses;
+        });
+        postUpdate(set, get);
+    },
+    setMfoConfigurationTypesCriterion: (mfoConfigurationTypes) => {
+        set((draft) => {
+            draft.mfoConfigurationTypes = mfoConfigurationTypes;
+        });
+        postUpdate(set, get);
+    },
+    setMarkerTypesCriterion: (markerTypes) => {
+        set((draft) => {
+            draft.markerTypes = markerTypes;
+        });
+        postUpdate(set, get);
+    },
+    setMarkerStatusCriterion: (status) => {
+        set((draft) => {
+            draft.markerStatus = status;
+        });
+        postUpdate(set, get);
+    },
+    setProcessorLogEntryType: entryType => {
+        console.log('setProcessorLogEntryType', entryType);
+        set((draft) => {
+            draft.processorLogEntryType = entryType;
+        });
+        postUpdate(set, get);
+    },
+    setErrorCodeCriterion: errorCode => {
+        set(draft => {
+            draft.errorCode = errorCode;
+        });
+        postUpdate(set, get);
+    },
+    triggerSearch: () => {
+        const currentSearchCriteria = extractSearchCriteriaFromState(get());
+        get().onFiltersUpdate(currentSearchCriteria);
+        set((draft) => {
+            draft.hasUnappliedFilters = false;
+        });
+    },
+});
+const addInitialMultigetCriterionReducer = (draft, criterionType) => {
+    switch (criterionType) {
+        case CriterionTypeEnum.ENDPOINT:
+            draft.multigetCriteria.push(getInitialMultigetCriterion(LinkedEntityTypeEnum.ENDPOINT));
+            break;
+        case CriterionTypeEnum.PROJECT:
+            draft.multigetCriteria.push(getInitialMultigetCriterion(LinkedEntityTypeEnum.PROJECT));
+            break;
+        case CriterionTypeEnum.COMPANY:
+            draft.multigetCriteria.push(getInitialMultigetCriterion(LinkedEntityTypeEnum.COMPANY));
+            break;
+        case CriterionTypeEnum.GATE:
+            draft.multigetCriteria.push(getInitialMultigetCriterion(LinkedEntityTypeEnum.GATE));
+            break;
+        case CriterionTypeEnum.DEALER:
+            draft.multigetCriteria.push(getInitialMultigetCriterion(LinkedEntityTypeEnum.DEALER));
+            break;
+        case CriterionTypeEnum.MANAGER:
+            draft.multigetCriteria.push(getInitialMultigetCriterion(LinkedEntityTypeEnum.MANAGER));
+            break;
+        case CriterionTypeEnum.MERCHANT:
+            draft.multigetCriteria.push(getInitialMultigetCriterion(LinkedEntityTypeEnum.MERCHANT));
+            break;
+        case CriterionTypeEnum.PROCESSOR:
+            draft.multigetCriteria.push(getInitialMultigetCriterion(LinkedEntityTypeEnum.PROCESSOR));
+            break;
+        case CriterionTypeEnum.RESELLER:
+            draft.multigetCriteria.push(getInitialMultigetCriterion(LinkedEntityTypeEnum.RESELLER));
+            break;
+        case CriterionTypeEnum.CURRENCY:
+        case CriterionTypeEnum.EXACT:
+        case CriterionTypeEnum.ORDERS_SEARCH:
+        case CriterionTypeEnum.STATUS:
+        case CriterionTypeEnum.THREE_D:
+        case CriterionTypeEnum.DATE_RANGE:
+        case CriterionTypeEnum.DATE_RANGE_ORDERS:
+        case CriterionTypeEnum.PROJECT_CURRENCY:
+        case CriterionTypeEnum.CARD_TYPES:
+        case CriterionTypeEnum.TRANSACTION_TYPES:
+        case CriterionTypeEnum.TRANSACTION_STATUS:
+        case CriterionTypeEnum.TRANSACTION_SESSION_STATUS:
+        case CriterionTypeEnum.GROUPING:
+        case CriterionTypeEnum.RECURRENCE_TYPE:
+        case CriterionTypeEnum.RECURRENCE_STATUS:
+        case CriterionTypeEnum.MFO_CONFIGURATION_TYPE:
+        case CriterionTypeEnum.MARKER_TYPE:
+        case CriterionTypeEnum.MARKER_STATUS:
+        case CriterionTypeEnum.PROCESSOR_LOG_ENTRY_TYPE:
+        case CriterionTypeEnum.ERROR_CODE:
+        case CriterionTypeEnum.COUNTRIES:
+            // not multiget, so do nothing
+            break;
+        default:
+            exhaustiveCheck(criterionType);
+    }
+};
+const clearCriterionReducer = (draft, criterionType) => {
+    switch (criterionType) {
+        case CriterionTypeEnum.STATUS:
+            draft.status = getSearchUIInitialSearchCriteria(draft.defaults).status;
+            break;
+        case CriterionTypeEnum.THREE_D:
+            draft.threeD = getSearchUIInitialSearchCriteria(draft.defaults).threeD;
+            break;
+        case CriterionTypeEnum.EXACT:
+            draft.exactSearchLabel = draft.exactSearchLabels[0];
+            draft.exactSearchValue = getSearchUIInitialSearchCriteria(draft.defaults).exactSearchValue;
+            break;
+        case CriterionTypeEnum.ORDERS_SEARCH:
+            draft.ordersSearchLabel = 'merchant_invoice_id';
+            draft.ordersSearchValue = '';
+            break;
+        case CriterionTypeEnum.CURRENCY:
+            draft.currencies = searchUIInitialAllableCollection;
+            break;
+        case CriterionTypeEnum.COUNTRIES:
+            draft.countries = searchUICountriesInitialAllableCollection;
+            break;
+        case CriterionTypeEnum.DATE_RANGE_ORDERS:
+            draft.orderDateType = 'SESSION_STATUS_CHANGED';
+            draft.dateRangeSpec = getSearchUIInitialSearchCriteria(draft.defaults).dateRangeSpec;
+            break;
+        case CriterionTypeEnum.DATE_RANGE:
+            draft.dateRangeSpec = getSearchUIInitialSearchCriteria(draft.defaults).dateRangeSpec;
+            break;
+        case CriterionTypeEnum.PROJECT:
+            removeMultigetCriterionReducer(draft, LinkedEntityTypeEnum.PROJECT);
+            break;
+        case CriterionTypeEnum.ENDPOINT:
+            removeMultigetCriterionReducer(draft, LinkedEntityTypeEnum.ENDPOINT);
+            break;
+        case CriterionTypeEnum.GATE:
+            removeMultigetCriterionReducer(draft, LinkedEntityTypeEnum.GATE);
+            break;
+        case CriterionTypeEnum.PROCESSOR:
+            removeMultigetCriterionReducer(draft, LinkedEntityTypeEnum.PROCESSOR);
+            break;
+        case CriterionTypeEnum.COMPANY:
+            removeMultigetCriterionReducer(draft, LinkedEntityTypeEnum.COMPANY);
+            break;
+        case CriterionTypeEnum.MANAGER:
+            removeMultigetCriterionReducer(draft, LinkedEntityTypeEnum.MANAGER);
+            break;
+        case CriterionTypeEnum.MERCHANT:
+            removeMultigetCriterionReducer(draft, LinkedEntityTypeEnum.MERCHANT);
+            break;
+        case CriterionTypeEnum.RESELLER:
+            removeMultigetCriterionReducer(draft, LinkedEntityTypeEnum.RESELLER);
+            break;
+        case CriterionTypeEnum.DEALER:
+            removeMultigetCriterionReducer(draft, LinkedEntityTypeEnum.DEALER);
+            break;
+        case CriterionTypeEnum.PROJECT_CURRENCY:
+            draft.projectCurrency = getSearchUIInitialProjectCurrency(draft.defaults);
+            break;
+        case CriterionTypeEnum.CARD_TYPES:
+            draft.cardTypes = searchUIInitialAllableCollection;
+            break;
+        case CriterionTypeEnum.TRANSACTION_TYPES:
+            draft.transactionTypes = searchUIInitialAllableCollection;
+            break;
+        case CriterionTypeEnum.TRANSACTION_STATUS:
+            draft.transactionStatuses = searchUIInitialAllableCollection;
+            break;
+        case CriterionTypeEnum.TRANSACTION_SESSION_STATUS: {
+            draft.transactionSessionStatusGroup = 'APPROVED';
+            const statuses = draft.prefetchedData.transactionSessionStatuses?.get('APPROVED') ?? [];
+            draft.transactionSessionStatuses = [...statuses];
+            break;
+        }
+        case CriterionTypeEnum.GROUPING:
+            draft.grouping = getSearchUIInitialGrouping(draft.defaults);
+            break;
+        case CriterionTypeEnum.RECURRENCE_TYPE:
+            draft.recurrenceTypes = searchUIInitialAllableCollection;
+            break;
+        case CriterionTypeEnum.RECURRENCE_STATUS:
+            draft.recurrenceStatuses = searchUIInitialAllableCollection;
+            break;
+        case CriterionTypeEnum.MFO_CONFIGURATION_TYPE:
+            draft.mfoConfigurationTypes = searchUIInitialAllableCollection;
+            break;
+        case CriterionTypeEnum.MARKER_TYPE:
+            draft.markerTypes = searchUIInitialAllableCollection;
+            break;
+        case CriterionTypeEnum.MARKER_STATUS:
+            draft.markerStatus = getSearchUIInitialSearchCriteria(draft.defaults).markerStatus;
+            break;
+        case CriterionTypeEnum.PROCESSOR_LOG_ENTRY_TYPE:
+            draft.processorLogEntryType = getSearchUIInitialSearchCriteria(draft.defaults).processorLogEntryType;
+            break;
+        case CriterionTypeEnum.ERROR_CODE:
+            draft.errorCode = getSearchUIInitialSearchCriteria(draft.defaults).errorCode;
+            break;
+        default:
+            exhaustiveCheck(criterionType);
+            throw new Error('Unknown criterion type: ' + criterionType);
+    }
+};
+const removeMultigetCriterionReducer = (draft, entityType) => {
+    const index = draft.multigetCriteria.findIndex(c => c.entityType === entityType);
+    if (index >= 0) {
+        draft.multigetCriteria.splice(index, 1);
+    }
+};
+const extractStatus = (status) => {
+    if (status === 'ENABLED') {
+        return 'E';
+    }
+    if (status === 'DISABLED') {
+        return 'D';
+    }
+    return null;
+};
+const extractMarkerStatus = (status) => {
+    if (status === 'any') {
+        return null;
+    }
+    return status;
+};
+const extractProcessorLogEntryType = (type) => {
+    if (type === null || !type.id || type.displayName === '') {
+        return null;
+    }
+    return type.displayName;
+};
+const extractErrorCode = (code) => {
+    if (code === null || code.choiceId === undefined || code.choiceId === null) {
+        return null;
+    }
+    return code.choiceId;
+};
+const extract3D = (threeD) => {
+    if (threeD === ThreeDCriterionEnum.YES) {
+        return true;
+    }
+    if (threeD === ThreeDCriterionEnum.NO) {
+        return false;
+    }
+    return null;
+};
+const extractExactSearchLabel = (label) => {
+    if (label === ExactCriterionSearchLabelEnum.ALL || label === undefined) {
+        return null;
+    }
+    return label;
+};
+const extractEntitiesIds = (allable) => {
+    if (allable.all) {
+        return [];
+    }
+    if (!allable.entities) {
+        console.warn('This is weird that allable.entities is undefined');
+        return [];
+    }
+    return allable.entities.map(c => c.id);
+};
+const extractGroupTypes = (grouping) => {
+    const groups = [...grouping.selectedGroupingTypes];
+    const dateGroupIndex = groups.indexOf('DATE');
+    if (~dateGroupIndex) {
+        groups[dateGroupIndex] = grouping.dateType;
+    }
+    return groups;
+};
+const extractDateFrom = (dateRangeSpec, useTime) => {
+    if (dateRangeSpec.dateRangeSpecType === 'DATE_INDEPENDENT') {
+        return dayjs().year(2000).toDate();
+    }
+    if (dateRangeSpec.dateRangeSpecType === 'EXACTLY'
+        && !useTime
+        && dateRangeSpec.dateFrom) {
+        return dayjs(dateRangeSpec.dateFrom).startOf('day').toDate();
+    }
+    return dateRangeSpec.dateFrom;
+};
+const extractDateTo = (dateRangeSpec, useTime) => {
+    if (dateRangeSpec.dateRangeSpecType === 'DATE_INDEPENDENT') {
+        return dayjs().year(2999).toDate();
+    }
+    else if (dateRangeSpec.dateRangeSpecType === 'EXACTLY') {
+        if (useTime) {
+            return dateRangeSpec.dateTo;
+        }
+        return dayjs(dateRangeSpec.dateTo)
+            .startOf('day')
+            .add(1, 'd')
+            .toDate();
+    }
+    else {
+        return dateRangeSpec.dateTo;
+    }
+};
+const extractTransactionSessionStatuses = (criteria, statuses) => {
+    if (!criteria.includes(CriterionTypeEnum.TRANSACTION_SESSION_STATUS))
+        return null;
+    const selectedStatuses = statuses
+        .filter(status => status.selected)
+        .map(status => status.displayName);
+    return selectedStatuses.length ? selectedStatuses.join(',') : null;
+};
+const copyTransactionSessionStatuses = (statuses) => {
+    return statuses.map(status => ({ ...status }));
+};
+const createTransactionSessionStatusesPrefetchedMap = (source) => {
+    return new Map(Object.entries(source).map(([group, statuses]) => [
+        group,
+        copyTransactionSessionStatuses(statuses),
+    ]));
+};
+function ensureTransactionSessionStatusesPrefetched(set, get) {
+    const state = get();
+    if (!state.criteria.includes(CriterionTypeEnum.TRANSACTION_SESSION_STATUS)) {
+        return;
+    }
+    const { prefetchedData, prefetchedDataLoading, prefetchedDataMeta } = state;
+    const prefetchedMap = prefetchedData.transactionSessionStatuses;
+    if (prefetchedMap) {
+        if (prefetchedDataMeta.transactionSessionStatusesPrefilled) {
+            return;
+        }
+        const currentGroup = state.transactionSessionStatusGroup;
+        const prefetched = prefetchedMap.get(currentGroup) ?? [];
+        let statusesUpdated = false;
+        set(draft => {
+            if (!draft.prefetchedDataMeta.transactionSessionStatusesPrefilled) {
+                if (draft.transactionSessionStatuses.length === 0) {
+                    draft.transactionSessionStatuses = copyTransactionSessionStatuses(prefetched);
+                    statusesUpdated = true;
+                }
+                draft.prefetchedDataMeta.transactionSessionStatusesPrefilled = true;
+            }
+        });
+        if (statusesUpdated) {
+            checkIfFiltersChanged(set, get);
+        }
+        return;
+    }
+    if (prefetchedDataLoading.transactionSessionStatuses) {
+        return;
+    }
+    set(draft => {
+        draft.prefetchedDataLoading.transactionSessionStatuses = true;
+    });
+    state.defaults.getTransactionSessionStatuses()
+        .then(statusesMap => {
+        let statusesUpdated = false;
+        const statuses = createTransactionSessionStatusesPrefetchedMap(statusesMap);
+        set(draft => {
+            draft.prefetchedData.transactionSessionStatuses = statuses;
+            draft.prefetchedDataLoading.transactionSessionStatuses = false;
+            if (!draft.prefetchedDataMeta.transactionSessionStatusesPrefilled) {
+                if (draft.transactionSessionStatuses.length === 0) {
+                    const currentGroup = draft.transactionSessionStatusGroup;
+                    const prefetched = statuses.get(currentGroup) ?? [];
+                    draft.transactionSessionStatuses = copyTransactionSessionStatuses(prefetched);
+                    statusesUpdated = true;
+                }
+                draft.prefetchedDataMeta.transactionSessionStatusesPrefilled = true;
+            }
+        });
+        if (statusesUpdated) {
+            checkIfFiltersChanged(set, get);
+        }
+    })
+        .catch(error => {
+        console.error(error);
+        set(draft => {
+            draft.prefetchedDataLoading.transactionSessionStatuses = false;
+        });
+    });
+}
+const postUpdate = (set, get, options) => {
+    syncCriterionAvailability(set, get);
+    ensureTransactionSessionStatusesPrefetched(set, get);
+    checkIfFiltersChanged(set, get, options);
+};
+const syncCriterionAvailability = (set, get) => {
+    const criteriaWithRules = getCriteriaWithAvailabilityRules(get().config);
+    if (!criteriaWithRules.length) {
+        return;
+    }
+    set(draft => {
+        const maxPasses = criteriaWithRules.length + 1;
+        for (let pass = 0; pass < maxPasses; pass++) {
+            let changed = false;
+            criteriaWithRules.forEach(criterion => {
+                if (isCriterionAvailable(criterion, draft, draft.config)) {
+                    if (draft.predefinedCriteria.includes(criterion)
+                        && !draft.criteria.includes(criterion)) {
+                        restorePredefinedCriterionReducer(draft, criterion);
+                        changed = true;
+                    }
+                    return;
+                }
+                clearCriterionReducer(draft, criterion);
+                if (draft.criteria.includes(criterion)) {
+                    draft.criteria = draft.criteria.filter(activeCriterion => activeCriterion !== criterion);
+                    changed = true;
+                }
+            });
+            if (!changed) {
+                return;
+            }
+        }
+    });
+};
+const restorePredefinedCriterionReducer = (draft, criterion) => {
+    addInitialMultigetCriterionReducer(draft, criterion);
+    const activePredefinedCriteria = draft.predefinedCriteria.filter(predefinedCriterion => (predefinedCriterion === criterion || draft.criteria.includes(predefinedCriterion)));
+    const activeCustomCriteria = draft.criteria.filter(activeCriterion => (!draft.predefinedCriteria.includes(activeCriterion)));
+    draft.criteria = Array.from(new Set([
+        ...activePredefinedCriteria,
+        ...activeCustomCriteria,
+    ]));
+};
+const checkIfFiltersChanged = (set, get, options) => {
+    const currentSearchCriteria = extractSearchCriteriaFromState(get());
+    if (!isEqual(get().prevSearchCriteria, currentSearchCriteria)) {
+        const isManualSearch = get().config?.manualSearch;
+        const isInitialLoad = get().prevSearchCriteria === null;
+        const shouldForceSearch = options?.forceSearch === true;
+        if (isManualSearch && !isInitialLoad && !shouldForceSearch) {
+            set((draft) => {
+                draft.prevSearchCriteria = currentSearchCriteria;
+                draft.hasUnappliedFilters = true;
+            });
+        }
+        else {
+            get().onFiltersUpdate(currentSearchCriteria);
+            set((draft) => {
+                draft.prevSearchCriteria = currentSearchCriteria;
+                draft.hasUnappliedFilters = false;
+            });
+        }
+    }
+};
+const extractSearchCriteriaFromState = (state) => {
+    const timeSelectionEnabled = state.criteria.includes(CriterionTypeEnum.DATE_RANGE_ORDERS)
+        || !!state.config?.dateRange?.enableTimeSelection;
+    return {
+        initialized: true,
+        exactSearchLabel: extractExactSearchLabel(state.exactSearchLabel),
+        exactSearchValue: state.exactSearchValue,
+        ordersSearchLabel: state.ordersSearchLabel,
+        ordersSearchValue: state.ordersSearchValue,
+        status: extractStatus(state.status),
+        threeD: extract3D(state.threeD),
+        currencies: extractEntitiesIds(state.currencies),
+        countries: extractEntitiesIds(state.countries),
+        dateFrom: extractDateFrom(state.dateRangeSpec, timeSelectionEnabled),
+        dateTo: extractDateTo(state.dateRangeSpec, timeSelectionEnabled),
+        orderDateType: state.orderDateType,
+        cardTypes: extractEntitiesIds(state.cardTypes),
+        transactionTypes: extractEntitiesIds(state.transactionTypes),
+        transactionStatuses: extractEntitiesIds(state.transactionStatuses),
+        transactionSessionStatuses: extractTransactionSessionStatuses(state.criteria, state.transactionSessionStatuses),
+        projectCurrencyId: state.projectCurrency.currency.id,
+        projectCurrencyConvert: state.projectCurrency.convertToUserCurrency,
+        groupTypes: extractGroupTypes(state.grouping),
+        multigetCriteria: state.multigetCriteria,
+        recurrenceTypes: extractEntitiesIds(state.recurrenceTypes),
+        recurrenceStatuses: extractEntitiesIds(state.recurrenceStatuses),
+        mfoConfigurationTypes: extractEntitiesIds(state.mfoConfigurationTypes),
+        markerTypes: extractEntitiesIds(state.markerTypes),
+        markerStatus: extractMarkerStatus(state.markerStatus),
+        processorLogEntryType: extractProcessorLogEntryType(state.processorLogEntryType),
+        errorCode: extractErrorCode(state.errorCode),
+    };
+};
+const getTemplate = (templateName, store) => ({
+    name: templateName,
+    searchConditions: {
+        criteria: store.criteria,
+        multigetCriteria: store.multigetCriteria,
+        exactSearchLabel: store.exactSearchLabel,
+        exactSearchValue: store.exactSearchValue,
+        ordersSearchLabel: store.ordersSearchLabel,
+        ordersSearchValue: store.ordersSearchValue,
+        status: store.status,
+        currencies: store.currencies,
+        countries: store.countries,
+        threeD: store.threeD,
+        orderDateType: store.orderDateType,
+        dateRangeSpec: store.dateRangeSpec,
+        projectCurrency: store.projectCurrency,
+        cardTypes: store.cardTypes,
+        transactionTypes: store.transactionTypes,
+        transactionStatuses: store.transactionStatuses,
+        transactionSessionStatusGroup: store.transactionSessionStatusGroup,
+        transactionSessionStatuses: store.transactionSessionStatuses,
+        grouping: store.grouping,
+        recurrenceTypes: store.recurrenceTypes,
+        recurrenceStatuses: store.recurrenceStatuses,
+        mfoConfigurationTypes: store.mfoConfigurationTypes,
+        markerTypes: store.markerTypes,
+        markerStatus: store.markerStatus,
+        processorLogEntryType: store.processorLogEntryType,
+        errorCode: store.errorCode,
+    },
+});
+const calculateNonExactDates = (dateRangeSpec) => {
+    const nowLocal = dayjs();
+    const nowServer = dayjs().utc().tz('Europe/Moscow');
+    let from = dateRangeSpec.dateFrom ? dayjs(dateRangeSpec.dateFrom)
+        : dayjs(searchUIInitialDateFrom);
+    let to = dateRangeSpec.dateTo ? dayjs(dateRangeSpec.dateTo)
+        : dayjs(searchUIInitialDateTo);
+    // endOf мы тут используем только при работе с месяцами или неделями. в случае дня, бд не различает начало и конец
+    // поэтом указываем начало следующего дня
+    switch (dateRangeSpec.dateRangeSpecType) {
+        case 'EXACTLY':
+            throw new Error('Don\'t do like this');
+        case 'DATE_INDEPENDENT':
+            break;
+        case 'TODAY':
+            from = nowLocal.startOf('day');
+            to = nowLocal.startOf('day').add(1, 'day');
+            break;
+        case 'YESTERDAY':
+            from = nowLocal.startOf('day').subtract(1, 'd');
+            to = nowLocal.startOf('day');
+            break;
+        case 'THIS_WEEK':
+            from = nowLocal.startOf('isoWeek');
+            to = nowLocal.endOf('isoWeek').add(1, 'day').startOf('day');
+            break;
+        case 'LAST_WEEK':
+            from = nowLocal.startOf('isoWeek').subtract(1, 'week');
+            to = nowLocal.endOf('isoWeek').subtract(1, 'week').add(1, 'day').startOf('day');
+            break;
+        case 'THIS_MONTH':
+            from = nowLocal.startOf('month');
+            to = nowLocal.endOf('month').add(1, 'day').startOf('day');
+            break;
+        case 'LAST_MONTH':
+            from = nowLocal.startOf('month').subtract(1, 'month');
+            to = nowLocal.subtract(1, 'month').endOf('month').add(1, 'day').startOf('day');
+            break;
+        case 'DAYS_BEFORE':
+            if (dateRangeSpec.beforeCount === null) {
+                throw new Error('Don\'t do like this');
+            }
+            from = nowLocal.startOf('day').subtract(dateRangeSpec.beforeCount, 'd');
+            to = nowLocal.startOf('day').add(1, 'day');
+            break;
+        case 'HOURS_BEFORE':
+            if (dateRangeSpec.beforeCount === null) {
+                throw new Error('Don\'t do like this');
+            }
+            to = nowServer;
+            from = nowServer.subtract(dateRangeSpec.beforeCount, 'hour');
+            break;
+        default:
+            exhaustiveCheck(dateRangeSpec.dateRangeSpecType);
+    }
+    return {
+        dateRangeSpecType: dateRangeSpec.dateRangeSpecType,
+        dateFrom: from.tz('Europe/Moscow', true).toDate(),
+        dateTo: to.tz('Europe/Moscow', true).toDate(),
+        beforeCount: dateRangeSpec.beforeCount,
+    };
+};
+export const OrdersSearchLabelsConfig = {
+    'merchant_invoice_id': { type: 'string', maxLength: 128 },
+    'order_id': { type: 'integer', maxLength: 10 },
+    'processor_order_id': { type: 'string', maxLength: 128 },
+    'purpose': { type: 'string', maxLength: 128 },
+    'transaction_amount': { type: 'amount', maxLength: 128 },
+    'session_token': { type: 'string', maxLength: 36 },
+    'customer_phone': { type: 'string', maxLength: 128 },
+    'customer_email': { type: 'string', maxLength: 128 },
+    'customer_ip': { type: 'ip', maxLength: 128 },
+    'customer_ip_country': { type: 'country', maxLength: 128 },
+    'customer_billing_country': { type: 'country', maxLength: 128 },
+    'customer_dna_id': { type: 'integer', maxLength: 10 },
+    'customer_id': { type: 'integer', maxLength: 10 },
+    'batch_id': { type: 'integer', maxLength: 10 },
+    'source_bank_name': { type: 'string', maxLength: 128 },
+    'source_country': { type: 'country', maxLength: 128 },
+    'source_from_order_id': { type: 'integer', maxLength: 10 },
+    'source_bin': { type: 'integer', maxLength: 6 },
+    'source_bin_range_from_order_id': { type: 'integer', maxLength: 10 },
+    'source_last4': { type: 'string', maxLength: 4 },
+    'source_bin_last4': { type: 'card6and4', maxLength: 128 },
+    'source_auth_code': { type: 'string', maxLength: 10 },
+    'source_arn': { type: 'string', maxLength: 64 },
+    'source_rrn': { type: 'string', maxLength: 20 },
+    'source_card_holder': { type: 'string', maxLength: 128 },
+    'source_card_ref_id': { type: 'integer', maxLength: 10 },
+    'dest_bank_name': { type: 'string', maxLength: 128 },
+    'dest_country': { type: 'country', maxLength: 128 },
+    'dest_from_order_id': { type: 'integer', maxLength: 10 },
+    'dest_bin': { type: 'integer', maxLength: 6 },
+    'dest_bin_range_from_order_id': { type: 'integer', maxLength: 10 },
+    'dest_last4': { type: 'string', maxLength: 4 },
+    'dest_bin_last': { type: 'card6and4', maxLength: 128 },
+    'dest_auth_code': { type: 'string', maxLength: 10 },
+    'dest_arn': { type: 'string', maxLength: 64 },
+    'dest_rrn': { type: 'string', maxLength: 20 },
+    'dest_card_ref_id': { type: 'integer', maxLength: 10 },
+    'account_number': { type: 'string', maxLength: 64 },
+    'routing_number': { type: 'string', maxLength: 16 },
+    'reader_key_serial_number': { type: 'string', maxLength: 16 },
+    'reader_device_serial_number': { type: 'string', maxLength: 16 },
+    'device_serial_number': { type: 'string', maxLength: 64 },
+    'phone_serial_number': { type: 'string', maxLength: 128 },
+    'phone_imei': { type: 'string', maxLength: 128 },
+    'reader_id': { type: 'string', maxLength: 128 },
+    'registration_info_id': { type: 'string', maxLength: 128 },
+    'inn': { type: 'string', maxLength: 128 },
+    'mtcn': { type: 'string', maxLength: 128 },
+    'rebill': { type: 'string', maxLength: 128 },
+    'swift_number': { type: 'string', maxLength: 128 },
+    'webmoney_account': { type: 'string', maxLength: 128 },
+    'yamoney_account': { type: 'string', maxLength: 128 },
+    'wire_account': { type: 'string', maxLength: 128 },
+    'card_number_hash_hash': { type: 'integer', maxLength: 10 },
+};
+//# sourceMappingURL=actions.js.map