@fast-simon/dashboard-utilities 1.0.35 → 1.0.37

package/dist/dashboard/dashboard-client/src/store/merchandisingConditions/merchandisingConditionsSlice.js

@@ -0,0 +1,665 @@
+import { createSlice } from "@reduxjs/toolkit";
+import { getEmptyConditionByRuleType, getEmptyMerchRule, } from "./utils";
+import { getRuleOperands } from "pages/Merchandising/rules/editor/utils";
+const initialState = {
+    merchandisingType: null,
+    rule: null,
+};
+export const merchandisingConditionsSlice = createSlice({
+    name: 'merchandisingConditions',
+    initialState,
+    reducers: {
+        reset: () => initialState,
+        setMerchandisingType(state, action) {
+            state.merchandisingType = action.payload;
+        },
+        setRule(state, action) {
+            state.rule = action.payload;
+            if (state.rule == null) {
+                return;
+            }
+        },
+        setRuleType(state, action) {
+            if (!state.rule) {
+                return;
+            }
+            const { isSource, type } = action.payload;
+            if (isSource) {
+                state.rule.sourceType = type;
+            }
+            else if (state.rule.type == "or" || state.rule.type == "and") {
+                state.rule.type = type;
+            }
+        },
+        setAction(state, action) {
+            if (!state.rule) {
+                return;
+            }
+            state.rule.action = action.payload;
+        },
+        setPromotionLevel(state, action) {
+            if (!state.rule) {
+                return;
+            }
+            if (action.payload) {
+                state.rule.promotionLevel = action.payload;
+            }
+            else {
+                delete state.rule.promotionLevel;
+            }
+        },
+        addCondition(state, action) {
+            const isSource = action.payload;
+            if (!state.rule) {
+                const emptyCondition = getEmptyConditionByRuleType(state.merchandisingType);
+                if (state.merchandisingType !== 'recommendations') {
+                    state.rule = emptyCondition;
+                }
+                else {
+                    state.rule = getEmptyMerchRule('recommendations');
+                    if (!isSource) {
+                        state.rule.operands = [emptyCondition];
+                    }
+                    else {
+                        const emptySourceCondition = getEmptyConditionByRuleType(state.merchandisingType);
+                        state.rule.sourceOperands = [emptySourceCondition];
+                    }
+                }
+            }
+            else if (state.merchandisingType === 'merchandisingRule') {
+                addConditionToMerchandisingRule(state);
+            }
+            else if (state.merchandisingType === 'landingPage') {
+                addConditionToLandingPageRule(state);
+            }
+            else if (state.merchandisingType == 'recommendations') {
+                const emptyCondition = getEmptyConditionByRuleType('recommendations');
+                let operands = getOperands(state, isSource);
+                //we assume that if the rule exist, there is already at least
+                //1 condition in the list of operands
+                if (operands) {
+                    operands.push(emptyCondition);
+                }
+                else {
+                    operands = [emptyCondition];
+                    setRuleOperands(state, operands, isSource);
+                }
+            }
+        },
+        addAndOrCondition(state, action) {
+            const { isSource, type } = action.payload;
+            if (!state.rule) {
+                const emptyCondition = getEmptyConditionByRuleType(state.merchandisingType);
+                if (state.merchandisingType !== 'recommendations') {
+                    state.rule = emptyCondition;
+                }
+                else {
+                    state.rule = getEmptyMerchRule('recommendations');
+                    if (!isSource) {
+                        state.rule.operands = [emptyCondition];
+                    }
+                    else {
+                        const emptySourceCondition = getEmptyConditionByRuleType(state.merchandisingType);
+                        state.rule.sourceOperands = [emptySourceCondition];
+                    }
+                }
+            }
+            else if (state.merchandisingType === 'merchandisingRule') {
+                addConditionToMerchandisingRule(state);
+            }
+            else if (state.merchandisingType === 'landingPage') {
+                addConditionToLandingPageRule(state);
+            }
+            else if (state.merchandisingType == 'recommendations') {
+                const emptyCondition = getEmptyConditionByRuleType('recommendations');
+                let operands = getOperands(state, isSource);
+                //we assume that if the rule exist, there is already at least
+                //1 condition in the list of operands
+                if (operands) {
+                    operands.push(emptyCondition);
+                }
+                else {
+                    operands = [emptyCondition];
+                    setRuleOperands(state, operands, isSource);
+                }
+            }
+            if (type) {
+                console.log(state.rule.type);
+                state.rule.type = type;
+            }
+        },
+        addNestedAndOrCondition(state, action) {
+            var _a, _b, _c, _d, _e;
+            const { isSource, type, operandIndex } = action.payload;
+            const operands = Object.assign({}, (_a = state.rule) === null || _a === void 0 ? void 0 : _a.operands[operandIndex]);
+            if (((_c = (_b = state.rule) === null || _b === void 0 ? void 0 : _b.operands[operandIndex]) === null || _c === void 0 ? void 0 : _c.type) !== 'and' && ((_e = (_d = state.rule) === null || _d === void 0 ? void 0 : _d.operands[operandIndex]) === null || _e === void 0 ? void 0 : _e.type) !== 'or') {
+                state.rule.operands[operandIndex] = {};
+                state.rule.operands[operandIndex].operands = [operands];
+            }
+            state.rule.operands[operandIndex].type = type;
+            const emptyCondition = getEmptyConditionByRuleType(state.merchandisingType);
+            if (state.merchandisingType !== 'recommendations') {
+                state.rule.operands[operandIndex].operands.push(emptyCondition);
+            }
+        },
+        setConditionType(state, action) {
+            if (state.merchandisingType === 'landingPage') {
+                return;
+            }
+            if (state.rule === null) {
+                return;
+            }
+            const { index, type, isSource } = action.payload;
+            if (isConditionInRuleRoot(state)) {
+                state.rule = setConditionType(type, state.rule);
+                return;
+            }
+            let condition = getConditionByIndex(state, index, isSource);
+            if (!condition) {
+                //should not happen, protection I guess
+                condition = getEmptyConditionByRuleType(state.merchandisingType);
+            }
+            let operands = getOperands(state, isSource);
+            if (!operands) {
+                //protection, should not happen
+                return;
+            }
+            operands[index] = setConditionType(type, condition);
+        },
+        setNestedConditionType(state, action) {
+            if (state.merchandisingType === 'landingPage') {
+                return;
+            }
+            if (state.rule === null) {
+                return;
+            }
+            const { index, nestedIndex, type, isSource } = action.payload;
+            if (isConditionInRuleRoot(state)) {
+                state.rule = setConditionType(type, state.rule);
+                return;
+            }
+            let condition = getConditionByIndex(state, index, isSource, nestedIndex);
+            if (!condition) {
+                //should not happen, protection I guess
+                condition = getEmptyConditionByRuleType(state.merchandisingType);
+            }
+            let operands = getOperands(state, isSource);
+            if (!operands) {
+                //protection, should not happen
+                return;
+            }
+            operands[index].operands[nestedIndex] = setConditionType(type, condition);
+        },
+        deleteCondition(state, action) {
+            const { index, isSource } = action.payload;
+            if (!state.rule) {
+                return;
+            }
+            else if (isConditionInRuleRoot(state)) {
+                if (state.merchandisingType == 'merchandisingRule') {
+                    return;
+                }
+                state.rule = null;
+            }
+            else {
+                if (state.merchandisingType !== 'landingPage') {
+                    let operands = getOperands(state, isSource);
+                    if (!operands || operands.length - 1 < index) {
+                        return;
+                    }
+                    operands = operands.filter((operand, i) => i !== index);
+                    if (operands.length == 0 && state.merchandisingType == 'merchandisingRule') {
+                        return;
+                    }
+                    setRuleOperands(state, operands, isSource);
+                }
+            }
+        },
+        deleteNestedCondition(state, action) {
+            var _a, _b;
+            const { index, nestedIndex, isSource } = action.payload;
+            if (!state.rule) {
+                return;
+            }
+            else if (isConditionInRuleRoot(state)) {
+                state.rule = null;
+            }
+            else {
+                if (state.merchandisingType !== 'landingPage') {
+                    let operands = getOperands(state, isSource);
+                    if (!operands || operands.length - 1 < index) {
+                        return;
+                    }
+                    if ((_a = operands[index]) === null || _a === void 0 ? void 0 : _a.operands) {
+                        (_b = operands[index]) === null || _b === void 0 ? void 0 : _b.operands.splice(nestedIndex, 1);
+                    }
+                    setRuleOperands(state, operands, isSource);
+                }
+            }
+        },
+        setConditionName(state, action) {
+            if (state.rule === null) {
+                return;
+            }
+            const { index, name, isSource } = action.payload;
+            const emptyCondition = getEmptyConditionByRuleType(state.merchandisingType);
+            let operator = getOperatorByConditionName(name, emptyCondition);
+            if (isConditionInRuleRoot(state)) {
+                state.rule = Object.assign(Object.assign({}, emptyCondition), { name: name });
+                if (operator) {
+                    state.rule = Object.assign(Object.assign({}, state.rule), { operator: operator });
+                }
+                else {
+                    delete state.rule['operator'];
+                }
+            }
+            else {
+                const operands = getOperands(state, isSource);
+                if (!operands) {
+                    return;
+                } //protection, should not happen
+                if (operator) {
+                    operands[index] = Object.assign(Object.assign({}, emptyCondition), { name: name, operator: operator });
+                }
+                else {
+                    let condition = Object.assign(Object.assign({}, emptyCondition), { name: name });
+                    delete condition['operator'];
+                    operands[index] = condition;
+                }
+            }
+        },
+        setNestedConditionName(state, action) {
+            if (state.rule === null) {
+                return;
+            }
+            const { index, nestedIndex, name, isSource } = action.payload;
+            const emptyCondition = getEmptyConditionByRuleType(state.merchandisingType);
+            let operator = getOperatorByConditionName(name, emptyCondition);
+            if (isConditionInRuleRoot(state)) {
+                state.rule = Object.assign(Object.assign({}, emptyCondition), { name: name });
+                if (operator) {
+                    state.rule = Object.assign(Object.assign({}, state.rule), { operator: operator });
+                }
+                else {
+                    delete state.rule['operator'];
+                }
+            }
+            else {
+                const operands = getOperands(state, isSource);
+                if (!operands) {
+                    return;
+                } //protection, should not happen
+                if (operator) {
+                    operands[index].operands[nestedIndex] = Object.assign(Object.assign({}, emptyCondition), { name: name, operator: operator });
+                }
+                else {
+                    let condition = Object.assign(Object.assign({}, emptyCondition), { name: name });
+                    delete condition['operator'];
+                    operands[index].operands[nestedIndex] = condition;
+                }
+            }
+        },
+        setConditionAttribute(state, action) {
+            var _a, _b;
+            if (state.rule === null) {
+                return;
+            }
+            const { index, attribute, isSource } = action.payload;
+            //this is only when the condition is in the rule root
+            if (state.rule.type === 'attribute') {
+                state.rule.name = attribute;
+                state.rule.value = state.rule.operator === 'not_exist' ? undefined : [];
+            }
+            else {
+                const operands = getOperands(state, isSource);
+                if (!operands) {
+                    return;
+                } //protection, should not happen
+                if (((_a = operands[index]) === null || _a === void 0 ? void 0 : _a.type) !== 'attribute') {
+                    return;
+                }
+                const condition = (_b = operands[index]) !== null && _b !== void 0 ? _b : getEmptyConditionByRuleType(state.merchandisingType);
+                const value = condition.operator === 'not_exist' ?
+                    undefined : [];
+                operands[index] = Object.assign(Object.assign({}, condition), { name: attribute, value: value });
+            }
+        },
+        setNestedConditionAttribute(state, action) {
+            var _a, _b;
+            if (state.rule === null) {
+                return;
+            }
+            const { index, nestedIndex, attribute, isSource } = action.payload;
+            //this is only when the condition is in the rule root
+            if (state.rule.type === 'attribute') {
+                state.rule.name = attribute;
+                state.rule.value = [];
+            }
+            else {
+                const operands = getOperands(state, isSource);
+                if (!operands) {
+                    return;
+                } //protection, should not happen
+                if (((_a = operands[index].operands[nestedIndex]) === null || _a === void 0 ? void 0 : _a.type) !== 'attribute') {
+                    return;
+                }
+                const condition = (_b = operands[index].operands[nestedIndex]) !== null && _b !== void 0 ? _b : getEmptyConditionByRuleType(state.merchandisingType);
+                operands[index].operands[nestedIndex] = Object.assign(Object.assign({}, condition), { name: attribute, value: [] });
+            }
+        },
+        setOperator(state, action) {
+            if (state.rule === null) {
+                return;
+            }
+            const { index, operator, isSource } = action.payload;
+            if (isConditionInRuleRoot(state)) {
+                const rule = state.rule;
+                rule.operator = operator;
+                if (operator === 'contains') {
+                    rule.value = rule.value.filter(v => v.indexOf('*') < 0);
+                }
+                else if (operator === 'not_exist') {
+                    rule.value = undefined;
+                }
+                else if (rule.value === undefined) {
+                    rule.value = [];
+                }
+            }
+            else {
+                const operands = getOperands(state, isSource);
+                if (!operands) {
+                    //should not happen
+                    return;
+                }
+                let condition = getConditionByIndex(state, index, isSource);
+                if (!condition) {
+                    condition = getEmptyConditionByRuleType(state.merchandisingType);
+                }
+                if ('operands' in condition) {
+                    return;
+                } //protection
+                let value = (operator === 'contains') ?
+                    condition.value.filter(v => v.indexOf('*') <= 0) : condition.value;
+                if (operator === 'not_exist') {
+                    value = undefined;
+                }
+                else if (value === undefined) {
+                    value = [];
+                }
+                operands[index] = Object.assign(Object.assign({}, condition), { operator: operator, value: value });
+            }
+        },
+        setNestedOperator(state, action) {
+            if (state.rule === null) {
+                return;
+            }
+            const { index, nestedIndex, operator, isSource } = action.payload;
+            if (isConditionInRuleRoot(state)) {
+                const rule = state.rule;
+                rule.operator = action.payload.operator;
+                const value = (action.payload.operator === 'contains') ?
+                    rule.value.filter(v => v.indexOf('*') < 0) : rule.value;
+                rule.value = value;
+            }
+            else {
+                const operands = getOperands(state, isSource);
+                if (!operands) {
+                    //should not happen
+                    return;
+                }
+                let condition = getConditionByIndex(state, index, isSource, nestedIndex);
+                if (!condition) {
+                    condition = getEmptyConditionByRuleType(state.merchandisingType);
+                }
+                if (('operands' in condition)) {
+                    return;
+                } //protection
+                const value = (action.payload.operator === 'contains') ?
+                    condition.value.filter(v => v.indexOf('*') <= 0) : condition.value;
+                operands[index].operands[nestedIndex] = Object.assign(Object.assign({}, condition), { operator: operator, value: value });
+            }
+        },
+        setValue(state, action) {
+            var _a;
+            if (state.rule === null) {
+                return;
+            }
+            const { index, value, isSource } = action.payload;
+            if (isConditionInRuleRoot(state)) {
+                state.rule.value = value;
+            }
+            else {
+                const rule = state.rule;
+                if (state.merchandisingType === 'landingPage' &&
+                    ((_a = rule.operands[action.payload.index]) === null || _a === void 0 ? void 0 : _a.type) !== 'attribute') {
+                    return;
+                }
+                const operands = getOperands(state, isSource);
+                if (!operands) {
+                    return; /* protection */
+                }
+                let condition = getConditionByIndex(state, index, isSource);
+                if (!condition) {
+                    condition = getEmptyConditionByRuleType(state.merchandisingType);
+                }
+                operands[index] = Object.assign(Object.assign({}, condition), { value: action.payload.value });
+            }
+        },
+        setNestedValue(state, action) {
+            var _a;
+            if (state.rule === null) {
+                return;
+            }
+            const { index, nestedIndex, value, isSource } = action.payload;
+            if (isConditionInRuleRoot(state)) {
+                state.rule.value = value;
+            }
+            else {
+                const rule = state.rule;
+                if (state.merchandisingType === 'landingPage' &&
+                    ((_a = rule.operands[index].operands[nestedIndex]) === null || _a === void 0 ? void 0 : _a.type) !== 'attribute') {
+                    return;
+                }
+                const operands = getOperands(state, isSource);
+                if (!operands) {
+                    return; /* protection */
+                }
+                let condition = getConditionByIndex(state, index, isSource, nestedIndex);
+                if (!condition) {
+                    condition = getEmptyConditionByRuleType(state.merchandisingType);
+                }
+                operands[index].operands[nestedIndex] = Object.assign(Object.assign({}, condition), { value: action.payload.value });
+            }
+        },
+        setPeriod(state, action) {
+            if (state.rule === null) {
+                return;
+            }
+            const { index, period, isSource } = action.payload;
+            if (isConditionInRuleRoot(state)) {
+                if (state.rule.type !== 'sales' && state.rule.name !== 'sales' &&
+                    state.rule.type !== 'conversion_rates' && state.rule.name !== 'conversion_rates' &&
+                    state.rule.type !== 'views' && state.rule.name !== 'views' &&
+                    state.rule.type !== 'product_returns' && state.rule.name !== 'product_returns') {
+                    return;
+                }
+                state.rule.period = period;
+            }
+            else {
+                const operands = getOperands(state, isSource);
+                if (!operands) {
+                    //protection, should not happen
+                    return;
+                }
+                let condition = getConditionByIndex(state, index, isSource);
+                if (!condition) {
+                    condition = getEmptyConditionByRuleType(state.merchandisingType);
+                }
+                if (condition.type !== 'sales' && condition.name !== 'sales'
+                    && condition.type !== 'views' && condition.type !== 'conversion_rates'
+                    && condition.type !== 'product_returns') {
+                    return;
+                }
+                operands[index] = Object.assign(Object.assign({}, condition), { period: period });
+            }
+        },
+        setNestedPeriod(state, action) {
+            if (state.rule === null) {
+                return;
+            }
+            const { index, nestedIndex, period, isSource } = action.payload;
+            if (isConditionInRuleRoot(state)) {
+                if (state.rule.type !== 'sales' && state.rule.name !== 'sales' &&
+                    state.rule.type !== 'conversion_rates' && state.rule.name !== 'conversion_rates' &&
+                    state.rule.type !== 'views' && state.rule.name !== 'views' &&
+                    state.rule.type !== 'product_returns' && state.rule.name !== 'product_returns') {
+                    return;
+                }
+                state.rule.period = period;
+            }
+            else {
+                const operands = getOperands(state, isSource);
+                if (!operands) {
+                    //protection, should not happen
+                    return;
+                }
+                let condition = getConditionByIndex(state, index, isSource, nestedIndex);
+                if (!condition) {
+                    condition = getEmptyConditionByRuleType(state.merchandisingType);
+                }
+                if (condition.type !== 'sales' && condition.name !== 'sales'
+                    && condition.type !== 'views' && condition.type !== 'conversion_rates'
+                    && condition.type !== 'product_returns') {
+                    return;
+                }
+                operands[index].operands[nestedIndex] = Object.assign(Object.assign({}, condition), { period: period });
+            }
+        }
+    }
+});
+function getOperatorByConditionName(name, emptyCondition) {
+    let operator;
+    if (name === 'Price' || name === 'rating' || name === 'popularity') {
+        operator = 'range';
+    }
+    else if (name === 'sales' || name == 'views' || name === 'conversion_rates' || name == 'product_returns') {
+        operator = undefined;
+    }
+    else {
+        operator = emptyCondition.operator;
+    }
+    return operator;
+}
+function extractConditionFromSingleMerchRule(rule) {
+    let resultRule = {
+        type: rule.type,
+        value: rule.value,
+        name: rule.name,
+        operator: rule.operator
+    };
+    if ((rule.type === 'sales' || rule.type === 'views' || rule.type === 'conversion_rates' || rule.type === 'product_returns')
+        && rule.period) {
+        return Object.assign(Object.assign({}, resultRule), { period: rule.period });
+    }
+    else {
+        return resultRule;
+    }
+}
+function setConditionType(type, condition) {
+    if (type !== 'attribute') {
+        condition = Object.assign(Object.assign({}, condition), { type: type, value: [] });
+        delete condition['name'];
+        delete condition['operator'];
+        delete condition['period'];
+    }
+    else {
+        condition = Object.assign(Object.assign({}, condition), { type: type, operator: 'in', value: [] });
+    }
+    if (type === 'widget') {
+        condition['operator'] = 'in';
+    }
+    if (type === 'rating' || type === 'popularity') {
+        condition['name'] = type;
+        condition['operator'] = 'range';
+    }
+    return condition;
+}
+function addConditionToMerchandisingRule(state) {
+    const emptyCondition = getEmptyConditionByRuleType(state.merchandisingType);
+    if (!('operands' in state.rule)) {
+        const condition = extractConditionFromSingleMerchRule(state.rule);
+        state.rule = {
+            type: 'and',
+            searchContextValues: undefined,
+            categoriesContextValues: undefined,
+            contextArr: [],
+            operands: [
+                condition,
+                emptyCondition
+            ],
+            action: 'promote',
+            promotionLevel: 1
+        };
+    }
+    else {
+        const multiRule = state.rule;
+        multiRule.operands.push(emptyCondition);
+    }
+}
+function addConditionToLandingPageRule(state) {
+    const emptyCondition = getEmptyConditionByRuleType(state.merchandisingType);
+    if (state.rule.type === 'attribute') {
+        state.rule = {
+            type: 'and',
+            operands: [
+                state.rule,
+                emptyCondition
+            ]
+        };
+    }
+    else {
+        const multiRule = state.rule;
+        multiRule.operands.push(emptyCondition);
+    }
+}
+const isConditionInRuleRoot = (state) => {
+    if (!state.rule) {
+        return false;
+    }
+    return !('operands' in state.rule) && state.merchandisingType !== 'recommendations';
+};
+const getOperands = (state, isSource) => {
+    return getRuleOperands(state.rule, state.merchandisingType, isSource);
+};
+const setRuleOperands = (state, operands, isSource) => {
+    if (!state.rule) {
+        return;
+    }
+    if (isSource) {
+        state.rule.sourceOperands = operands;
+    }
+    else {
+        state.rule.operands = operands;
+    }
+};
+const getConditionByIndex = (state, i, isSource, nestedIndex) => {
+    if (isSource) {
+        if (!state.rule.sourceOperands) {
+            return undefined;
+        }
+        else {
+            return state.rule.sourceOperands[i];
+        }
+    }
+    else {
+        if (nestedIndex != undefined) {
+            return state.rule.operands[i].operands[nestedIndex];
+        }
+        return state.rule.operands[i];
+    }
+};
+export const selectRule = (state) => state.merchandisingConditions.rule;
+export const selectMerchandisingType = (state) => state.merchandisingConditions.merchandisingType;
+export const setRule = merchandisingConditionsSlice.actions.setRule;
+export default merchandisingConditionsSlice.reducer;
+//# sourceMappingURL=merchandisingConditionsSlice.js.map