@fast-simon/dashboard-utilities 1.0.36 → 1.0.37

package/dist/dashboard/dashboard-client/src/store/merchandising/merchandisingSlice.js

@@ -0,0 +1,660 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { createAsyncThunk, createSlice } from "@reduxjs/toolkit";
+import { EditorVersion, MerchandisingType } from "./models";
+import { Merchandising } from "../../services/merchandising";
+import { deleteCollectionsMerchandisingRule, fetchCollectionsMerchandising, pushCollectionsRulesToSites, setCollectionsMerchandisingRule, updateShopifyCollection } from "./actions/collectionsActions";
+import { formatCollectionsMerchandisingRule, formatSearchMerchandisingRule } from "./rules";
+import { defaultMerchandisingStrategiesState } from "./models/strategiesModels";
+import { fetchMerchandisingStrategies, fetchStrategyStatus, updateMerchandisingStrategy } from "./actions/strategiesActions";
+import { resetState } from "../store";
+import { defaultEditedRule } from "./models/merchandisingRulesModels";
+import { NoResultsMode } from "./models/noResults";
+import { defaultProductMerchandising } from "./models/productMerchandising";
+import { fetchProductMerchandisingRanked, searchProductMerchandising, updateProductMerchandising } from "./actions/productActions";
+import { defaultPreviewConfig } from "./models/previewConfig";
+import { fetchPreviewConfig } from "./actions/configActions";
+import { rebuildStrategiesGroupOrder } from "../../pages/Merchandising/MerchandisingStrategies/utils";
+import { addBanner, deleteBanner, editBanner, fetchBanners } from "./actions/bannerActions";
+import { getToggledEditorVersionVal } from "../../pages/Merchandising/editor/utils";
+const initialState = {
+    searchMerchandising: {
+        isLoading: true,
+        rules: [],
+        editorVersion: EditorVersion.JQUERY,
+        isShowUpgrade: false
+    },
+    merchandisingStrategies: defaultMerchandisingStrategiesState,
+    productMerchandising: defaultProductMerchandising,
+    geographies: {
+        countryCode: "",
+        geographies: {}
+    },
+    merchandisingRules: {
+        errorMessage: '',
+        rules: [],
+        editedRule: defaultEditedRule,
+        isOpenEditor: false,
+        preview: {
+            scope: { type: '', value: '' },
+            scopeRules: []
+        }
+    },
+    collectionsMerchandising: {
+        rules: [],
+        isWriteProductsShopifyPermission: false,
+        editorVersion: EditorVersion.REACT,
+        isShowUpgrade: false
+    },
+    collectionPushedToShopify: null,
+    noResults: {
+        mode: NoResultsMode.Auto,
+        products_ids: [],
+        banner_html: ''
+    },
+    table: {
+        collectionsMerchandising: {
+            page: 1,
+            resultsPerPage: 25,
+            query: ""
+        },
+        searchMerchandising: {
+            page: 1,
+            resultsPerPage: 25,
+            query: ""
+        }
+    },
+    loading: {
+        collectionsMerchandising: {
+            rules: true,
+            pushingToShopify: false,
+            pushToSites: false
+        },
+        merchandisingRules: {
+            rules: false,
+            pushToSites: false
+        }
+    },
+    dataReceived: false,
+    previewConfig: defaultPreviewConfig,
+    segmentInPreview: "",
+    promotiles: [],
+    promotilesLoading: false,
+    banners: [],
+    bannersLoading: false,
+    relatedCollections: [],
+    editorProductsPerPage: { search: 30, collection: 30 }
+};
+export const fetchPromotiles = createAsyncThunk('merchandising/fetchPromotiles', () => __awaiter(void 0, void 0, void 0, function* () {
+    return (yield Merchandising.fetchPromotiles()).data;
+}));
+export const addPromotile = createAsyncThunk('merchandising/addPromotile', (promotile) => __awaiter(void 0, void 0, void 0, function* () {
+    return (yield Merchandising.addPromotile(promotile)).data;
+}));
+export const editPromotile = createAsyncThunk('merchandising/editPromotile', (promotile) => __awaiter(void 0, void 0, void 0, function* () {
+    return (yield Merchandising.editPromotile(promotile)).data;
+}));
+export const deletePromotile = createAsyncThunk('merchandising/deletePromotile', (id) => __awaiter(void 0, void 0, void 0, function* () {
+    return (yield Merchandising.deletePromotile(id)).data;
+}));
+export const fetchMerchandising = createAsyncThunk('merchandising/fetchMerchandising', () => __awaiter(void 0, void 0, void 0, function* () {
+    return (yield Merchandising.fetchMerchandising()).data;
+}));
+export const fetchSearchMerchandising = createAsyncThunk('merchandising/fetchSearchMerchandising', () => __awaiter(void 0, void 0, void 0, function* () {
+    return (yield Merchandising.fetchSearchMerchandising()).data;
+}));
+export const fetchGeographies = createAsyncThunk('merchandising/fetchGeographies', () => __awaiter(void 0, void 0, void 0, function* () {
+    return (yield Merchandising.fetchGeographies()).data;
+}));
+export const uploadSearchMerchandisingRules = createAsyncThunk('merchandising/uploadSearchMerchandisingRules', ({ rules, ruleIndex }) => __awaiter(void 0, void 0, void 0, function* () {
+    return (yield Merchandising.uploadSearchMerchandisingRules(rules, ruleIndex)).data;
+}));
+export const resetVariationMerchandisingRules = createAsyncThunk('merchandising/resetVariationMerchandisingRules', (variation_id) => __awaiter(void 0, void 0, void 0, function* () {
+    return (yield Merchandising.resetVariationMerchandisingRules(variation_id)).data;
+}));
+export const clearVariationMerchandisingRules = createAsyncThunk('merchandising/clearVariationMerchandisingRules', (variation_id) => __awaiter(void 0, void 0, void 0, function* () {
+    return (yield Merchandising.clearVariationMerchandisingRules(variation_id)).data;
+}));
+export const fetchMerchandisingRulesRules = createAsyncThunk('merchandising/fetchMerchandisingRulesRules', (variation_id) => __awaiter(void 0, void 0, void 0, function* () {
+    return (yield Merchandising.fetchMerchandisingRulesRules(variation_id)).data;
+}));
+export const uploadMerchRulesRules = createAsyncThunk('merchandising/uploadMerchandisingRulesRules', ({ rules, oldRules, variation_id }, { rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const data = (yield Merchandising.uploadMerchandisingRulesRules(rules, variation_id)).data;
+        if (!data.success) {
+            console.error('Failed to save rule.');
+        }
+        return data;
+    }
+    catch (error) {
+        console.error(error);
+        return rejectWithValue(null);
+    }
+}));
+export const getProductsPerPage = createAsyncThunk('merchandising/getProductsPerPage', () => __awaiter(void 0, void 0, void 0, function* () {
+    return (yield Merchandising.getProductsPerPage()).data;
+}));
+/**
+ * Removes pinned products that have negative indexes or that are in the promoted region.
+ * @param pinned
+ * @param promoted
+ */
+export function fixPinnedProducts(pinned, promoted) {
+    return pinned.filter(([index]) => index >= promoted.length);
+}
+export const fetchNoResultsConfig = createAsyncThunk('merchandising/fetchNoResultsConfig', () => __awaiter(void 0, void 0, void 0, function* () {
+    return (yield Merchandising.fetchNoResultsConfig()).data;
+}));
+export const setNoResultsMerchandisingMode = createAsyncThunk('merchandising/setNoResultsMerchandisingMode', (mode) => __awaiter(void 0, void 0, void 0, function* () {
+    return (yield Merchandising.setNoResultsMerchandisingMode(mode)).data;
+}));
+export const setNoResultsMerchandisingRule = createAsyncThunk('merchandising/setNoResultsMerchandisingRule', ({ productsIds, bannerHtml }) => __awaiter(void 0, void 0, void 0, function* () {
+    return (yield Merchandising.setNoResultsMerchandisingRule(productsIds, bannerHtml)).data;
+}));
+export const pushMerchandisingRulesToSites = createAsyncThunk('merchandising/pushMerchandisingRulesToSites', ({ sites }) => __awaiter(void 0, void 0, void 0, function* () {
+    return (yield Merchandising.pushMerchandisingRulesToSites(sites)).data;
+}));
+export const toggleEditorVersion = createAsyncThunk('merchandising/toggleEditorVersion', ({ merchType, version }) => __awaiter(void 0, void 0, void 0, function* () {
+    return (yield Merchandising.toggleEditorVersion(merchType, version)).data;
+}));
+const merchandisingSlice = createSlice({
+    name: 'merchandising',
+    initialState,
+    reducers: {
+        setMerchRulesEditedRule: (state, action) => {
+            state.merchandisingRules.editedRule = action.payload;
+        },
+        setMerchandisingRulesEditedIndex: (state, action) => {
+            state.merchandisingRules.editedRule.index = action.payload;
+        },
+        setMerchRulesIsSearchContext: (state, action) => {
+            state.merchandisingRules.editedRule.isSearchContext = action.payload;
+        },
+        setMerchRulesIsAllQueries: (state, action) => {
+            state.merchandisingRules.editedRule.isAllQueries = action.payload;
+        },
+        setMerchRulesSearchContextValues: (state, action) => {
+            state.merchandisingRules.editedRule.searchContextValues = action.payload;
+        },
+        setMerchRulesIsCategoriesContext: (state, action) => {
+            state.merchandisingRules.editedRule.isCategoriesContext = action.payload;
+        },
+        setMerchRulesIsAllCategories: (state, action) => {
+            state.merchandisingRules.editedRule.isAllCategories = action.payload;
+        },
+        setMerchRulesCategoriesContextValues: (state, action) => {
+            state.merchandisingRules.editedRule.categoriesContextValues = action.payload;
+        },
+        setMerchRulesRuleType: (state, action) => {
+            state.merchandisingRules.editedRule.type = action.payload;
+        },
+        setMerchRulesAction: (state, action) => {
+            state.merchandisingRules.editedRule.action = action.payload;
+        },
+        setMerchRulesPromotionLevel: (state, action) => {
+            state.merchandisingRules.editedRule.promotionLevel = action.payload;
+        },
+        setMerchRulesSegments: (state, action) => {
+            state.merchandisingRules.editedRule.segments = action.payload;
+        },
+        setMerchRulesErrorMessage: (state, action) => {
+            state.merchandisingRules.errorMessage = action.payload;
+        },
+        setMerchRulesPreviewScope: (state, action) => {
+            state.merchandisingRules.preview.scope = action.payload;
+        },
+        setMerchRulesPreviewScopeRules: (state, action) => {
+            state.merchandisingRules.preview.scopeRules = action.payload;
+        },
+        toggleDataReceived: (state, action) => {
+            state.dataReceived = action.payload;
+        },
+        setCollectionTablePage: (state, action) => {
+            state.table.collectionsMerchandising.page = action.payload;
+        },
+        setCollectionTableResultsPerPage: (state, action) => {
+            state.table.collectionsMerchandising.resultsPerPage = action.payload;
+        },
+        setCollectionTableQuery: (state, action) => {
+            state.table.collectionsMerchandising.query = action.payload;
+        },
+        resetCollectionTable: (state) => {
+            state.table.collectionsMerchandising = initialState.table.collectionsMerchandising;
+        },
+        setSearchTablePage: (state, action) => {
+            state.table.searchMerchandising.page = action.payload;
+        },
+        setSearchTableResultsPerPage: (state, action) => {
+            state.table.searchMerchandising.resultsPerPage = action.payload;
+        },
+        setSearchTableQuery: (state, action) => {
+            state.table.searchMerchandising.query = action.payload;
+        },
+        resetSearchTable: (state) => {
+            state.table.searchMerchandising = initialState.table.searchMerchandising;
+        },
+        setSegmentInPreview: (state, action) => {
+            state.segmentInPreview = action.payload;
+        },
+        setIsShowEditorUpgrade: (state, action) => {
+            if (action.payload.merchType === MerchandisingType.COLLECTIONS) {
+                state.collectionsMerchandising.isShowUpgrade = action.payload.value;
+            }
+            else if (action.payload.merchType === MerchandisingType.SEARCH) {
+                state.searchMerchandising.isShowUpgrade = action.payload.value;
+            }
+        },
+        setEditorVersion: (state, action) => {
+            setEditorVersionState(state, action.payload.merchType, action.payload.version);
+        }
+    },
+    extraReducers: builder => {
+        builder.addCase(resetState, () => initialState);
+        builder.addCase(fetchPromotiles.pending, (state, action) => {
+            state.promotilesLoading = true;
+        });
+        builder.addCase(fetchPromotiles.fulfilled, (state, action) => {
+            state.promotiles = action.payload.promotiles;
+            state.promotilesLoading = false;
+        });
+        builder.addCase(addPromotile.pending, (state, action) => {
+            state.promotiles = [...state.promotiles, action.meta.arg];
+        });
+        builder.addCase(addPromotile.fulfilled, (state, action) => {
+            const promotileId = state.promotiles.findIndex((promotile) => promotile.id === "");
+            state.promotiles[promotileId].id = action.payload.id;
+        });
+        builder.addCase(editPromotile.pending, (state, action) => {
+            const promotileId = state.promotiles.findIndex((promotile) => promotile.id === action.meta.arg.id);
+            state.promotiles[promotileId] = action.meta.arg;
+        });
+        builder.addCase(deletePromotile.pending, (state, action) => {
+            state.promotiles = state.promotiles.filter((promotile) => promotile.id !== action.meta.arg);
+        });
+        builder.addCase(fetchMerchandising.fulfilled, (state, action) => {
+            //not in use
+        });
+        builder.addCase(fetchSearchMerchandising.fulfilled, (state, action) => {
+            state.searchMerchandising = {
+                rules: action.payload.rules.map(rule => formatSearchMerchandisingRule(rule)),
+                editorVersion: action.payload.editorVersion,
+                isShowUpgrade: action.payload.isShowUpgrade,
+                isLoading: false
+            };
+        });
+        builder.addCase(fetchMerchandisingStrategies.pending, (state, action) => {
+            state.merchandisingStrategies.status = "loading";
+        });
+        builder.addCase(fetchMerchandisingStrategies.rejected, (state, action) => {
+            state.merchandisingStrategies.status = "error";
+        });
+        builder.addCase(fetchMerchandisingStrategies.fulfilled, (state, action) => {
+            const strategies = rebuildStrategiesGroupOrder(action.payload.strategies);
+            state.merchandisingStrategies = {
+                status: "fulfilled",
+                strategies: strategies
+            };
+        });
+        builder.addCase(updateMerchandisingStrategy.pending, (state, action) => {
+            let { strategy, key } = action.meta.arg;
+            if (action.meta.arg.action === "add") {
+                strategy.status = "saving";
+                state.merchandisingStrategies.strategies.push(strategy);
+            }
+            else if (action.meta.arg.action === "delete") {
+                state.merchandisingStrategies.strategies = state.merchandisingStrategies.strategies.filter(s => s.key !== key);
+            }
+            else if (action.meta.arg.action === "change") {
+                strategy.status = "updating";
+                state.merchandisingStrategies.strategies = state.merchandisingStrategies.strategies.map(s => {
+                    if (key === s.key) {
+                        return strategy;
+                    }
+                    return s;
+                });
+            }
+        });
+        builder.addCase(updateMerchandisingStrategy.rejected, (state, action) => {
+            if (action.meta.arg.action === "add") {
+                state.merchandisingStrategies.strategies = state.merchandisingStrategies.strategies.map(s => {
+                    if (!s.key) {
+                        s.status = "error";
+                    }
+                    return s;
+                });
+            }
+        });
+        builder.addCase(updateMerchandisingStrategy.fulfilled, (state, action) => {
+            state.merchandisingStrategies.strategies = state.merchandisingStrategies.strategies.map(s => {
+                if (!s.key) {
+                    s.key = action.payload;
+                }
+                return s;
+            });
+        });
+        builder.addCase(fetchStrategyStatus.fulfilled, (state, action) => {
+            const strategyKey = action.meta.arg.key;
+            state.merchandisingStrategies.strategies = state.merchandisingStrategies.strategies.map(s => {
+                if (s.key === strategyKey) {
+                    s.status = action.payload.status ? "ready" : s.status;
+                }
+                return s;
+            });
+        });
+        builder.addCase(fetchGeographies.fulfilled, (state, action) => {
+            state.geographies = action.payload;
+        });
+        builder.addCase(fetchMerchandisingRulesRules.pending, (state, action) => {
+            state.loading.merchandisingRules.rules = true;
+            state.merchandisingRules.errorMessage = '';
+        });
+        builder.addCase(fetchMerchandisingRulesRules.rejected, (state, action) => {
+            state.loading.merchandisingRules.rules = false;
+        });
+        builder.addCase(fetchMerchandisingRulesRules.fulfilled, (state, action) => {
+            state.loading.merchandisingRules.rules = false;
+            if (action.payload.success) {
+                state.merchandisingRules.rules = action.payload.rules;
+            }
+        });
+        builder.addCase(uploadMerchRulesRules.pending, (state, action) => {
+            state.merchandisingRules.errorMessage = '';
+            state.merchandisingRules.rules = action.meta.arg.rules;
+        });
+        builder.addCase(uploadMerchRulesRules.rejected, (state, action) => {
+            state.merchandisingRules.errorMessage =
+                'There was an error while saving the rule, please try again.';
+            state.merchandisingRules.rules = action.meta.arg.oldRules;
+        });
+        builder.addCase(uploadMerchRulesRules.fulfilled, (state, action) => {
+            if (action.payload.success === false) {
+                state.merchandisingRules.errorMessage =
+                    'There was an error while saving the rule, please try again.';
+                state.merchandisingRules.rules = action.meta.arg.oldRules;
+            }
+        });
+        builder.addCase(resetVariationMerchandisingRules.pending, (state, action) => {
+            state.loading.merchandisingRules.rules = true;
+        });
+        builder.addCase(resetVariationMerchandisingRules.rejected, (state, action) => {
+        });
+        builder.addCase(resetVariationMerchandisingRules.fulfilled, (state, action) => {
+            state.merchandisingRules.rules = action.payload.rules;
+            state.loading.merchandisingRules.rules = false;
+        });
+        builder.addCase(clearVariationMerchandisingRules.pending, (state, action) => {
+            state.loading.merchandisingRules.rules = true;
+        });
+        builder.addCase(clearVariationMerchandisingRules.fulfilled, (state, action) => {
+            state.merchandisingRules.rules = [];
+            state.loading.merchandisingRules.rules = false;
+        });
+        builder.addCase(uploadSearchMerchandisingRules.pending, (state, action) => {
+            state.searchMerchandising.rules = action.meta.arg.rules;
+        });
+        builder.addCase(uploadSearchMerchandisingRules.fulfilled, (state, action) => {
+            state.searchMerchandising.rules = action.payload.rules.map(rule => (Object.assign(Object.assign({}, rule), { isNew: false })));
+        });
+        builder.addCase(fetchCollectionsMerchandising.pending, state => {
+            state.loading.collectionsMerchandising.rules = true;
+        });
+        builder.addCase(fetchCollectionsMerchandising.fulfilled, (state, action) => {
+            const rules = action.payload.rules;
+            state.collectionsMerchandising.rules =
+                rules.map(rule => formatCollectionsMerchandisingRule(rule));
+            state.collectionsMerchandising.editorVersion = action.payload.editorVersion;
+            state.collectionsMerchandising.isShowUpgrade = action.payload.isShowUpgrade;
+            state.collectionsMerchandising.isWriteProductsShopifyPermission =
+                action.payload.isWriteProductsShopifyPermission;
+            state.loading.collectionsMerchandising.rules = false;
+        });
+        builder.addCase(setCollectionsMerchandisingRule.pending, (state, action) => {
+            var _a, _b;
+            const newRule = {
+                ruleInput: action.meta.arg.rule.ruleInput,
+                promoted: action.meta.arg.rule.promoted,
+                buried: action.meta.arg.rule.buried,
+                hidden: action.meta.arg.rule.hidden,
+                pinned: action.meta.arg.rule.pinned.map(([index, id]) => [index, id.toString()]),
+                promotiles: (_a = action.meta.arg.rule.promotiles) !== null && _a !== void 0 ? _a : {},
+                start_time: action.meta.arg.rule.start_time,
+                end_time: action.meta.arg.rule.end_time,
+                description: action.meta.arg.rule.description,
+                geos: action.meta.arg.rule.geos,
+                banner_html: action.meta.arg.rule.banner_html,
+                banner_html_mobile: action.meta.arg.rule.banner_html_mobile,
+                last_modified: null,
+                isNew: true,
+                id: action.meta.arg.rule.id,
+                relatedCollections: action.meta.arg.rule.relatedCollections,
+                selectedBannerId: (_b = action.meta.arg.rule.selectedBannerId) !== null && _b !== void 0 ? _b : '',
+            };
+            const rules = state.collectionsMerchandising.rules;
+            const existingRuleIndex = rules.findIndex(rule => rule.id === newRule.id);
+            if (existingRuleIndex !== -1) {
+                state.collectionsMerchandising.rules[existingRuleIndex] = newRule;
+            }
+            else {
+                state.collectionsMerchandising.rules.push(newRule);
+            }
+        });
+        builder.addCase(setCollectionsMerchandisingRule.fulfilled, (state, action) => {
+            state.collectionsMerchandising.rules =
+                state.collectionsMerchandising.rules.map(rule => {
+                    if (!rule.isNew) {
+                        return rule;
+                    }
+                    return Object.assign(Object.assign({}, rule), { isNew: false, id: action.payload.id });
+                });
+        });
+        builder.addCase(setCollectionsMerchandisingRule.rejected, (state) => {
+            state.collectionsMerchandising.rules =
+                state.collectionsMerchandising.rules.map(rule => {
+                    return Object.assign(Object.assign({}, rule), { isNew: false });
+                });
+        });
+        builder.addCase(deleteCollectionsMerchandisingRule.pending, (state, action) => {
+            state.collectionsMerchandising.rules =
+                state.collectionsMerchandising.rules.filter(rule => rule.id !== action.meta.arg.ruleId);
+        });
+        builder.addCase(updateShopifyCollection.pending, (state, action) => {
+            state.loading.collectionsMerchandising.pushingToShopify = true;
+            state.collectionPushedToShopify = action.meta.arg;
+        });
+        builder.addCase(updateShopifyCollection.fulfilled, (state, action) => {
+            state.loading.collectionsMerchandising.pushingToShopify = false;
+            state.collectionPushedToShopify = null;
+        });
+        builder.addCase(updateShopifyCollection.rejected, (state, action) => {
+            state.loading.collectionsMerchandising.pushingToShopify = false;
+            state.collectionPushedToShopify = null;
+        });
+        builder.addCase(pushCollectionsRulesToSites.pending, (state) => {
+            state.loading.collectionsMerchandising.pushToSites = true;
+        });
+        builder.addCase(pushCollectionsRulesToSites.fulfilled, (state) => {
+            state.loading.collectionsMerchandising.pushToSites = false;
+        });
+        builder.addCase(pushCollectionsRulesToSites.rejected, (state) => {
+            state.loading.collectionsMerchandising.pushToSites = false;
+        });
+        builder.addCase(pushMerchandisingRulesToSites.pending, (state) => {
+            state.loading.merchandisingRules.pushToSites = true;
+            state.loading.merchandisingRules.rules = true;
+        });
+        builder.addCase(pushMerchandisingRulesToSites.fulfilled, (state, action) => {
+            state.loading.merchandisingRules.pushToSites = false;
+            state.loading.merchandisingRules.rules = false;
+            if (action.payload.success) {
+                state.merchandisingRules.rules = action.payload.rules;
+            }
+        });
+        builder.addCase(pushMerchandisingRulesToSites.rejected, (state) => {
+            state.loading.merchandisingRules.pushToSites = false;
+            state.loading.merchandisingRules.rules = false;
+        });
+        builder.addCase(fetchNoResultsConfig.fulfilled, (state, action) => {
+            state.noResults.mode = action.payload.mode;
+            state.noResults.products_ids = action.payload.data.products_ids;
+            state.noResults.banner_html = action.payload.data.banner_html;
+        });
+        builder.addCase(setNoResultsMerchandisingMode.pending, (state, action) => {
+            state.noResults.mode = action.meta.arg;
+        });
+        builder.addCase(setNoResultsMerchandisingRule.pending, (state, action) => {
+            state.noResults.products_ids = action.meta.arg.productsIds;
+            state.noResults.banner_html = action.meta.arg.bannerHtml;
+        });
+        builder.addCase(setNoResultsMerchandisingMode.rejected, (state, action) => {
+            state.noResults.mode = action.meta.arg === NoResultsMode.Auto ? NoResultsMode.Manual : NoResultsMode.Auto;
+        });
+        builder.addCase(fetchProductMerchandisingRanked.fulfilled, (state, action) => {
+            state.productMerchandising.productRanking = action.payload;
+            state.productMerchandising.isLoading.ranked = false;
+        });
+        builder.addCase(searchProductMerchandising.pending, (state, action) => {
+            state.productMerchandising.query = action.meta.arg.query;
+            state.productMerchandising.isLoading.search = true;
+        });
+        builder.addCase(searchProductMerchandising.fulfilled, (state, action) => {
+            state.productMerchandising.searchProducts = action.payload;
+            state.productMerchandising.isLoading.search = false;
+        });
+        builder.addCase(fetchPreviewConfig.fulfilled, (state, action) => {
+            state.previewConfig = Object.assign(Object.assign({}, action.payload), { isLoading: false });
+        });
+        builder.addCase(updateProductMerchandising.pending, (state, action) => {
+            const { source, product } = action.meta.arg;
+            if (source === "ranking") {
+                if (product.ranking !== 0) {
+                    // update ranking for a product inside the current group
+                    state.productMerchandising.productRanking = state.productMerchandising.productRanking.map(p => {
+                        if (p.id === product.id) {
+                            return product;
+                        }
+                        return p;
+                    });
+                }
+                else {
+                    state.productMerchandising.productRanking = state.productMerchandising.productRanking.filter(p => p.id !== product.id);
+                }
+                // id might be in search product as well
+                state.productMerchandising.searchProducts = state.productMerchandising.searchProducts.map(p => {
+                    if (p.id === product.id) {
+                        return product;
+                    }
+                    return p;
+                });
+            }
+            else {
+                if (product.ranking !== 0) {
+                    // move to current group and remove from search group
+                    state.productMerchandising.productRanking.unshift(product);
+                    state.productMerchandising.searchProducts = state.productMerchandising.searchProducts.filter(p => p.id !== product.id);
+                }
+            }
+        });
+        builder.addCase(toggleEditorVersion.pending, (state, action) => {
+            setEditorVersionState(state, action.meta.arg.merchType, action.meta.arg.version);
+        });
+        builder.addCase(toggleEditorVersion.rejected, (state, action) => {
+            const toggledVersion = getToggledEditorVersionVal(action.meta.arg.version);
+            setEditorVersionState(state, action.meta.arg.merchType, toggledVersion);
+        });
+        builder.addCase(fetchBanners.pending, (state, action) => {
+            state.bannersLoading = true;
+        });
+        builder.addCase(fetchBanners.fulfilled, (state, action) => {
+            state.banners = action.payload.banners;
+            state.bannersLoading = false;
+        });
+        builder.addCase(addBanner.pending, (state, action) => {
+            state.banners = [...state.banners, action.meta.arg];
+        });
+        builder.addCase(editBanner.pending, (state, action) => {
+        });
+        builder.addCase(deleteBanner.pending, (state, action) => {
+            state.banners = state.banners.filter((banner) => banner.id !== action.meta.arg);
+        });
+        builder.addCase(getProductsPerPage.fulfilled, (state, action) => {
+            state.editorProductsPerPage = action.payload.products_per_page;
+        });
+    }
+});
+export const selectPromotiles = (state) => ({
+    promotiles: state.merchandising.promotiles,
+    isLoading: state.merchandising.promotilesLoading
+});
+export const selectSearchMerchandisingRules = (state) => state.merchandising.searchMerchandising;
+export const selectMerchandisingStrategies = (state) => state.merchandising.merchandisingStrategies;
+export const selectGeographies = (state) => state.merchandising.geographies;
+export const selectMerchandisingRules = (state) => state.merchandising.merchandisingRules;
+export const selectCollectionsMerchandising = (state) => state.merchandising.collectionsMerchandising;
+export const selectMerchandisingLoading = (state) => state.merchandising.loading;
+export const selectCollectionPushedToShopify = (state) => state.merchandising.collectionPushedToShopify;
+export const selectNoResultsMode = (state) => state.merchandising.noResults.mode;
+export const selectNoResultsProducts = (state) => state.merchandising.noResults.products_ids;
+export const selectNoResultsBanner = (state) => state.merchandising.noResults.banner_html;
+export const selectProductMerchandising = (state) => state.merchandising.productMerchandising;
+export const selectIsDataReceivedMerch = (state) => state.merchandising.dataReceived;
+export const selectMerchandisingPreviewConfig = (state) => state.merchandising.previewConfig;
+export const selectMerchandisingCollectionTable = (state) => state.merchandising.table.collectionsMerchandising;
+export const selectMerchandisingSearchTable = (state) => state.merchandising.table.searchMerchandising;
+export const selectMerchRulesEditedRuleSegments = (state) => state.merchandising.merchandisingRules.editedRule.segments;
+export const selectSegmentInPreview = (state) => state.merchandising.segmentInPreview;
+export const selectCollectionsEditorVersion = (state) => state.merchandising.collectionsMerchandising.editorVersion;
+export const selectSearchEditorVersion = (state) => state.merchandising.searchMerchandising.editorVersion;
+export const selectIsShowCollectionsEditorUpgrade = (state) => state.merchandising.collectionsMerchandising.isShowUpgrade;
+export const selectIsShowSearchEditorUpgrade = (state) => state.merchandising.searchMerchandising.isShowUpgrade;
+export const selectProductsPerPage = (state) => state.merchandising.editorProductsPerPage;
+export const selectBanners = (state) => ({
+    banners: state.merchandising.banners,
+    isLoading: state.merchandising.bannersLoading
+});
+export const setMerchRulesIsSearchContext = merchandisingSlice.actions.setMerchRulesIsSearchContext;
+export const setMerchRulesIsAllQueries = merchandisingSlice.actions.setMerchRulesIsAllQueries;
+export const setMerchRulesSearchContextValues = merchandisingSlice.actions.setMerchRulesSearchContextValues;
+export const setMerchRulesIsCategoriesContext = merchandisingSlice.actions.setMerchRulesIsCategoriesContext;
+export const setMerchRulesIsAllCategories = merchandisingSlice.actions.setMerchRulesIsAllCategories;
+export const setMerchRulesCategoriesContextValues = merchandisingSlice.actions.setMerchRulesCategoriesContextValues;
+export const setMerchRulesRuleType = merchandisingSlice.actions.setMerchRulesRuleType;
+export const setMerchRulesEditedRule = merchandisingSlice.actions.setMerchRulesEditedRule;
+export const setMerchRulesAction = merchandisingSlice.actions.setMerchRulesAction;
+export const setMerchRulesPromotionLevel = merchandisingSlice.actions.setMerchRulesPromotionLevel;
+export const setMerchRulesSegments = merchandisingSlice.actions.setMerchRulesSegments;
+export const setMerchRulesErrorMessage = merchandisingSlice.actions.setMerchRulesErrorMessage;
+export const setMerchRulesPreviewScope = merchandisingSlice.actions.setMerchRulesPreviewScope;
+export const setMerchRulesPreviewScopeRules = merchandisingSlice.actions.setMerchRulesPreviewScopeRules;
+export const setMerchDataReceived = merchandisingSlice.actions.toggleDataReceived;
+export const setIsShowEditorUpgrade = merchandisingSlice.actions.setIsShowEditorUpgrade;
+export const setEditorVersion = merchandisingSlice.actions.setEditorVersion;
+export const setMerchCollectionTable = {
+    setPage: merchandisingSlice.actions.setCollectionTablePage,
+    setResultPerPage: merchandisingSlice.actions.setCollectionTableResultsPerPage,
+    setQuery: merchandisingSlice.actions.setCollectionTableQuery,
+    reset: merchandisingSlice.actions.resetCollectionTable
+};
+export const setMerchSearchTable = {
+    setPage: merchandisingSlice.actions.setSearchTablePage,
+    setResultPerPage: merchandisingSlice.actions.setSearchTableResultsPerPage,
+    setQuery: merchandisingSlice.actions.setSearchTableQuery,
+    reset: merchandisingSlice.actions.resetSearchTable,
+};
+function setEditorVersionState(state, merchType, version) {
+    if (merchType === MerchandisingType.COLLECTIONS) {
+        state.collectionsMerchandising.editorVersion = version;
+    }
+    else if (merchType === MerchandisingType.SEARCH) {
+        state.searchMerchandising.editorVersion = version;
+    }
+}
+export const setSegmentInPreview = merchandisingSlice.actions.setSegmentInPreview;
+export default merchandisingSlice.reducer;
+//# sourceMappingURL=merchandisingSlice.js.map