@fast-simon/dashboard-utilities 1.0.35 → 1.0.37

package/dist/dashboard/dashboard-client/src/store/sync/syncSlice.js

@@ -0,0 +1,966 @@
+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 { toggleProductImageSource } from "../../containers/sync/ProductImageSource/utils";
+import { AVOID_TYPE } from "./models";
+import { Sync } from "../../services/sync";
+import { resetState } from "../store";
+import { syncInProgressMessage } from "../../containers/sync/CustomCsvInfo/utils";
+import { TIME_MS } from "../../utils/dateAndTime";
+import { setPricingStringInput, setPricingSwitch } from "./PricingActions";
+import { serverErrorMessage } from "../../pages/Sync/MetafieldAttributes/utils";
+import { SYNC_PROGRESS_UPDATES_NUM, syncErrorMessage, syncNowMessage, syncStartedMessage } from "../../containers/sync/ProductSync/utils";
+import { adminSaveErrorMessage } from 'containers/sync/RestrictedAdmins/RestrictedAdminEdit/utils';
+import { defaultSyncState } from 'pages/Sync/utils';
+export const fetchSyncSettings = createAsyncThunk('sync/fetchSyncSettings', () => __awaiter(void 0, void 0, void 0, function* () {
+    return (yield Sync.getSyncSettings()).data;
+}));
+export const fetchOnReenterTab = createAsyncThunk('sync/fetchOnReenterTab', () => __awaiter(void 0, void 0, void 0, function* () {
+    return (yield Sync.fetchOnReenterTabSettings()).data;
+}));
+/* sync on demand for Shopify */
+export const startSyncOnDemandShopify = createAsyncThunk('sync/processUpdateQueue', ({ siteHost, processQueueOnly }) => {
+    return Sync.startSyncOnDemandShopify(siteHost, processQueueOnly);
+});
+/* sync on demand for Magento, BigCommerce, WooCommerce */
+export const startSyncOnDemand = createAsyncThunk('sync/userUpdateCatalog', () => {
+    return Sync.startSyncOnDemand();
+});
+export const setEnableProducts = createAsyncThunk('sync/setEnableProducts', ({ isEnable }) => {
+    return Sync.enableProducts(isEnable);
+});
+export const getWooSyncWarnings = createAsyncThunk('sync/getWooSyncWarnings', () => {
+    return Sync.getWooSyncWarnings();
+});
+export const getBigcommerceSyncWarnings = createAsyncThunk('sync/getBigcommerceSyncWarnings', () => {
+    return Sync.getBigcommerceSyncWarnings();
+});
+export const setSyncOption = createAsyncThunk('sync/setSyncOption', ({ optionID, optionName, optionValue }) => {
+    return Sync.setSyncOption(optionID, optionValue);
+});
+export const setProductImageOptimization = createAsyncThunk('sync/setProductImageOptimization', ({ value }) => {
+    return Sync.setProductImageOptimization(value);
+});
+export const setTagManagerProvider = createAsyncThunk('sync/setTagManagerProvider', ({ tagManagerProvider }) => {
+    return Sync.setTagManagerProvider(tagManagerProvider);
+});
+export const setSkuSyncOption = createAsyncThunk('sync/setSkuSyncOption', ({ isSkuIndex, isSkuTypoCorrection, isSkuExactMatch, optionName, optionValue }) => {
+    return Sync.setSkuSyncOption(isSkuIndex, isSkuTypoCorrection, isSkuExactMatch);
+});
+export const setDescSyncOption = createAsyncThunk('sync/setDescSyncOption', ({ isDescIndex, isShortDescIndex, optionName, optionValue }) => {
+    return Sync.setDescSyncOption(isDescIndex, isShortDescIndex);
+});
+export const setCustomAttr = createAsyncThunk('sync/setCustomAttr', (customAttr) => {
+    return Sync.setCustomAttr(customAttr);
+});
+export const setVariantOptions = createAsyncThunk('sync/setVariantOptions', (variantOptions) => {
+    return Sync.setVariantOptions(variantOptions);
+});
+export const setProductsAttributeMetafields = createAsyncThunk('sync/setProductsAttributeMetafields', (values) => {
+    return Sync.setProductsAttributeMetafields(values);
+});
+export const setVariantsAttributeMetafields = createAsyncThunk('sync/setVariantsAttributeMetafields', (values) => {
+    return Sync.setVariantsAttributeMetafields(values);
+});
+export const setNonSellableProducts = createAsyncThunk('sync/setNonSellableProducts', ({ isShow, isDemote, isShowOld, isDemoteOld }) => {
+    return Sync.setNonSellableProducts(isShow, isDemote);
+});
+export const setProductImageSource = createAsyncThunk('sync/setProductImageSource', (source) => {
+    return Sync.setProductImageSource(source);
+});
+export const setProductCreationDateSource = createAsyncThunk('sync/setProductCreationDateSource', (args) => {
+    return Sync.setProductCreationDateSource(args.source, args.metafield);
+});
+export const setHideProducts = createAsyncThunk('sync/setHideProducts', ({ avoidValues, avoidType }) => {
+    return Sync.setHideProducts(avoidValues, avoidType);
+});
+export const setExcludeTagsFromSync = createAsyncThunk('sync/setExcludeTagsFromSync', (tags) => {
+    return Sync.setExcludeTagsFromSync(tags);
+});
+/* called on sync tab first load, and after the sync has begun */
+export const checkSiteState = createAsyncThunk('sync/checkSiteState', () => __awaiter(void 0, void 0, void 0, function* () {
+    return (yield Sync.checkSiteState()).data;
+}));
+export const saveSiteGroupUserPassword = createAsyncThunk('sync/saveSiteGroupUserPassword', ({ username, password }) => {
+    return Sync.setSiteGroupUserPassword(username, password);
+});
+export const validateSiteGroupUserPassword = createAsyncThunk('sync/validateSiteGroupUserPassword', ({ username, password }) => {
+    return Sync.validateSiteGroupUserPassword(username, password);
+});
+export const getHowIpsSeesProduct = createAsyncThunk('sync/getHowIpsSeesProduct', (productName) => {
+    return Sync.getHowIpsSeesProduct(productName);
+});
+export const saveRestrictedAdmin = createAsyncThunk('sync/saveRestrictedAdmin', ({ email, password, roles, sites, isUpdate }) => {
+    return Sync.saveRestrictedAdmin(email, password, roles, sites, isUpdate);
+});
+export const deleteRestrictedAdmin = createAsyncThunk('sync/deleteRestrictedAdmin', (email) => {
+    return Sync.deleteSiteRestrictedAdmin(email);
+});
+export const uploadCsvToBlob = createAsyncThunk('sync/uploadCsvToBlob', ({ csvBlobUploadUrl, file, site_uuid, store_id, site_key, csv_encoding, is_strict, erase_all_missing_products, refresh_product_images }) => {
+    return Sync.uploadCsvToBlob(csvBlobUploadUrl, file, site_uuid, store_id, site_key, csv_encoding, is_strict, erase_all_missing_products, refresh_product_images);
+});
+export const getUploadCsvStatus = createAsyncThunk('sync/getUploadCsvStatus', () => {
+    return Sync.getUploadCsvStatus();
+});
+export const updateIpAddresses = createAsyncThunk('sync/updateIpAddresses', (ipAddresses) => __awaiter(void 0, void 0, void 0, function* () {
+    return (yield Sync.updateIpAddresses(ipAddresses)).data;
+}));
+export const fetchLocations = createAsyncThunk('sync/fetchLocations', () => __awaiter(void 0, void 0, void 0, function* () {
+    return (yield Sync.fetchLocations()).data;
+}));
+export const updateLocations = createAsyncThunk('sync/updateLocations', ({ syncedLocations }) => __awaiter(void 0, void 0, void 0, function* () {
+    return (yield Sync.updateLocations(syncedLocations)).data;
+}));
+export const syncSlice = createSlice({
+    name: 'sync',
+    initialState: defaultSyncState,
+    reducers: {
+        changeCurrentSite: (state, action) => {
+            state.currentSiteKey = action.payload;
+            state.loading.settings = true;
+        },
+        setSyncMessage: (state, action) => {
+            state.productSync.syncButtonText = action.payload.syncButtonText;
+            state.productSync.syncMessage = action.payload.syncMessage;
+        },
+        setSyncMessageTimeout: (state, action) => {
+            state.productSync.syncMessageTimeoutHandler = action.payload;
+        },
+        setSyncProgressTimeout: (state, action) => {
+            state.productSync.syncProgressTimeoutHandler = action.payload;
+        },
+        setCustomAttrErrorMessage: (state, action) => {
+            state.customAttr.errorMessage = action.payload;
+            state.customAttr.isSaveError = state.customAttr.errorMessage !== '';
+        },
+        setInitialSiteStatus: (state, action) => {
+            state.mainSettings.siteStatus = action.payload.siteStatus;
+            state.mainSettings.isDisplaySiteStatusLoader = action.payload.isDisplaySiteStatusLoader;
+        },
+        setCustomAttributesTemp: (state, action) => {
+            state.customAttr.tempValues = action.payload;
+        },
+        setVariantOptionsTemp: (state, action) => {
+            state.variantOptions.values = action.payload;
+        },
+        setProductsAttributeMetafieldsErrorMessage: (state, action) => {
+            state.productsAttributeMetafields.errorMessage = action.payload;
+            state.productsAttributeMetafields.isSaveError = state.productsAttributeMetafields.errorMessage !== '';
+        },
+        setVariantsAttributeMetafieldsErrorMessage: (state, action) => {
+            state.variantsAttributeMetafields.errorMessage = action.payload;
+            state.variantsAttributeMetafields.isSaveError = state.variantsAttributeMetafields.errorMessage !== '';
+        },
+        setProductsAttributeMetafieldsTemp: (state, action) => {
+            state.productsAttributeMetafields.values = action.payload;
+        },
+        setVariantsAttributeMetafieldsTemp: (state, action) => {
+            state.variantsAttributeMetafields.values = action.payload;
+        },
+        setHideProductsTemp: (state, action) => {
+            const avoidType = action.payload.avoidType;
+            const avoidValues = action.payload.avoidValues;
+            if (avoidType === AVOID_TYPE.AVOID_PRODUCTS_WITH_TAGS) {
+                state.hideProducts.avoidProductsWithTags = avoidValues;
+            }
+            else if (avoidType === AVOID_TYPE.AVOID_PRODUCTS_WITH_METAFIELDS) {
+                state.hideProducts.avoidProductsWithMetafields = avoidValues;
+            }
+            else if (avoidType === AVOID_TYPE.AVOID_VARIANTS_WITH_METAFIELDS) {
+                state.hideProducts.avoidVariantsWithMetafields = avoidValues;
+            }
+        },
+        setSiteGroupUserPassword: (state, action) => {
+            state.editSettings.siteGroupUsername = action.payload.username;
+            state.editSettings.siteGroupPassword = action.payload.password;
+        },
+        setHowIspSeesProductName: (state, action) => {
+            state.howIspSees.productName = action.payload;
+        },
+        setEditedRestrictedAdmin: (state, action) => {
+            state.restrictedAdmins.editedAdmin.index = action.payload.index;
+            state.restrictedAdmins.editedAdmin.email = action.payload.email;
+            state.restrictedAdmins.editedAdmin.roles = action.payload.roles;
+            state.restrictedAdmins.editedAdmin.sites = action.payload.sites;
+            state.restrictedAdmins.editedAdmin.isSaveGood =
+                action.payload.isSaveGood;
+            if (typeof action.payload.password !== 'undefined') {
+                state.restrictedAdmins.editedAdmin.password =
+                    action.payload.password;
+            }
+        },
+        resetEditedRestrictedAdmin: (state, action) => {
+            state.restrictedAdmins.editedAdmin.index = -1;
+            state.restrictedAdmins.editedAdmin.email = '';
+            state.restrictedAdmins.editedAdmin.roles = [];
+            state.restrictedAdmins.editedAdmin.password = '';
+        },
+        setRestrictedAdminErrorMessage: (state, action) => {
+            const errorType = action.payload.errorType;
+            state.restrictedAdmins.errorMessages[errorType] = action.payload.message;
+        },
+        clearRestrictedAdminErrorMessage: (state, action) => {
+            state.restrictedAdmins.errorMessages['email'] = '';
+            state.restrictedAdmins.errorMessages['general'] = '';
+        },
+        setEditedRestrictedProp: (state, action) => {
+            if (action.payload.name in state.restrictedAdmins.editedAdmin) {
+                state.restrictedAdmins.editedAdmin[action.payload.name] =
+                    action.payload.value;
+            }
+        },
+        setCsvUploadFileName: (state, action) => {
+            state.customCsvInfo.uploadFileName = action.payload;
+        },
+        changeCustomCsvBooleanValue: (state, action) => {
+            const name = action.payload;
+            if (name === 'strictMode') {
+                state.customCsvInfo.isStrictMode =
+                    !state.customCsvInfo.isStrictMode;
+            }
+            else if (name === 'eraseExistingProducts') {
+                state.customCsvInfo.isEraseExistingProducts =
+                    !state.customCsvInfo.isEraseExistingProducts;
+            }
+            else if (name === 'refreshProductImages') {
+                state.customCsvInfo.isRefreshProductImages =
+                    !state.customCsvInfo.isRefreshProductImages;
+            }
+        },
+        setCsvUploadTimeout: (state, action) => {
+            state.customCsvInfo.csvUploadTimeoutHandler = action.payload;
+        },
+        setCsvUploadMessage: (state, action) => {
+            state.customCsvInfo.csvUploadMessage = action.payload;
+        },
+        setCsvUploadStatus: (state, action) => {
+            state.customCsvInfo.csvUploadStatus = action.payload;
+        },
+        setCsvEncoding: (state, action) => {
+            state.customCsvInfo.csvEncoding = action.payload;
+        },
+        setIsCsvUploading: (state, action) => {
+            state.customCsvInfo.isUploading = action.payload;
+        },
+        setCsvTimeToComplete: (state, action) => {
+            state.customCsvInfo.timeToComplete = action.payload;
+        },
+        setLastProductUpdateDate: (state, action) => {
+            state.productSync.lastProductUpdateDate = action.payload;
+        },
+        setCatalogLanguage: (state, action) => {
+            state.productSync.catalogLanguage = action.payload;
+        },
+        setProductCreationDateSourceValue: (state, action) => {
+            state.shProductCreationDateSource.source = action.payload;
+        },
+        setProductCreationDateSourceMetafield: (state, action) => {
+            state.shProductCreationDateSource.metafield = action.payload;
+        },
+        setSyncProgressCounter: (state, action) => {
+            state.productSync.syncProgressCounter = action.payload;
+        }
+    },
+    extraReducers: builder => {
+        builder.addCase(resetState, () => defaultSyncState);
+        builder.addCase(fetchSyncSettings.fulfilled, (state, action) => {
+            state.syncOptions = action.payload.syncOptions;
+            state.mainSettings.siteStatus = action.payload.mainSettings.siteStatus;
+            state.mainSettings.showTroubleshootingGuide =
+                action.payload.mainSettings.showTroubleshootingGuide;
+            state.editSettings.siteGroupUsername = action.payload.editSettings.siteGroupUsername;
+            state.editSettings.siteGroupPassword = action.payload.editSettings.siteGroupPassword;
+            state.magentoInfo.extensionVersion = action.payload.magentoInfo.extensionVersion;
+            state.magentoInfo.latestVersion = action.payload.magentoInfo.latestVersion;
+            state.magentoInfo.isLatestVersion = action.payload.magentoInfo.isLatestVersion;
+            state.magentoInfo.platformVersion = action.payload.magentoInfo.platformVersion;
+            state.magentoInfo.platformVersionType = action.payload.magentoInfo.platformVersionType;
+            state.woocommerceInfo = action.payload.woocommerceInfo;
+            state.customCsvInfo.curEmail = action.payload.customCsvInfo.curEmail;
+            state.customCsvInfo.csvBlobUploadUrl = action.payload.customCsvInfo.csvBlobUploadUrl;
+            state.customCsvInfo.csvUploadStatus = action.payload.customCsvInfo.csvUploadStatus;
+            state.customCsvInfo.isCsvUploaded = action.payload.customCsvInfo.isCsvUploaded;
+            state.customCsvInfo.csvUploadMessage = action.payload.customCsvInfo.csvUploadMessage;
+            state.customCsvInfo.timeToComplete = action.payload.customCsvInfo.timeToComplete;
+            state.productSync.isProductsEnabled = action.payload.productSync.isProductsEnabled;
+            state.productSync.lastProductUpdateDate = action.payload.productSync.lastProductUpdateDate;
+            state.productSync.syncMessage = action.payload.productSync.syncMessage;
+            state.productSync.isSyncOnDemandEnabled = action.payload.productSync.isSyncOnDemandEnabled;
+            state.productSync.catalogLanguage = action.payload.productSync.catalogLanguage;
+            state.productSync.leadSiteKey = action.payload.productSync.leadSiteKey;
+            state.productSync.canChangeProducts = action.payload.productSync.canChangeProducts;
+            state.productSync.productsCount = action.payload.productSync.productsCount;
+            state.productSync.isInitialSyncInProgress = action.payload.productSync.isInitialSyncInProgress;
+            if (state.productSync.isInitialSyncInProgress) {
+                state.productSync.isSyncButtonLoading = true;
+                state.productSync.syncButtonText = 'Syncing...';
+                state.productSync.syncMessage = 'Synchronizing products...';
+            }
+            state.syncWarnings.canCheckDebugSettings = action.payload.syncWarnings.canCheckDebugSettings;
+            state.syncWarnings.ispResultsPageType = action.payload.syncWarnings.ispResultsPageType;
+            state.customAttr.values = action.payload.customAttr.values;
+            state.customAttr.tempValues = action.payload.customAttr.values;
+            state.customAttr.options = action.payload.customAttr.options;
+            state.variantOptions.values = action.payload.variantOptions.values;
+            state.nonSellableProducts = action.payload.nonSellableProducts;
+            state.shProductImageSource = action.payload.shProductImageSource;
+            state.shProductCreationDateSource = action.payload.shProductCreationDateSource;
+            state.shProductCreationDateSource.oldSource = action.payload.shProductCreationDateSource.source;
+            state.shProductCreationDateSource.oldMetafield = action.payload.shProductCreationDateSource.metafield;
+            state.allDateProductsMetafields = action.payload.allDateProductsMetafields;
+            state.allProductsMetafields = action.payload.allProductsMetafields;
+            state.allVariantsMetafields = action.payload.allVariantsMetafields;
+            state.productsAttributeMetafields.values = action.payload.productsAttributeMetafields.values;
+            state.productsAttributeMetafields.savedValues = action.payload.productsAttributeMetafields.values;
+            state.variantsAttributeMetafields.values = action.payload.variantsAttributeMetafields.values;
+            state.variantsAttributeMetafields.savedValues = action.payload.variantsAttributeMetafields.values;
+            state.hideProducts.avoidProductsWithTags = action.payload.hideProducts.avoidProductsWithTags;
+            state.hideProducts.avoidProductsWithMetafields = action.payload.hideProducts.avoidProductsWithMetafields;
+            state.hideProducts.avoidVariantsWithMetafields = action.payload.hideProducts.avoidVariantsWithMetafields;
+            state.excludeTagsFromSync.tags = action.payload.excludeTagsFromSync.tags;
+            state.restrictedAdmins.admins = action.payload.restrictedAdmins.admins;
+            state.restrictedAdmins.siteAdminEmail = action.payload.restrictedAdmins.siteAdminEmail;
+            state.restrictedAdmins.groupOwnerEmail = action.payload.restrictedAdmins.groupOwnerEmail;
+            state.productImageOptimization.productImageOptimization = action.payload.useProductImageOptimization;
+            state.loading.settings = false;
+            state.pricingBooleanFields = action.payload.pricingBooleanFields;
+            state.pricingStringFields = action.payload.pricingStringFields;
+            state.updateIpAddresses.excludedIpAddresses = action.payload.updateIpAddresses.excludedIpAddresses;
+            state.updateIpAddresses.userIp = action.payload.updateIpAddresses.userIp;
+            state.tagManagerProvider.tagManagerProvider = action.payload.tagManagerProvider;
+        });
+        builder.addCase(fetchOnReenterTab.fulfilled, (state, action) => {
+            const productSyncData = action.payload.data.productSync;
+            state.productSync.lastProductUpdateDate = productSyncData.lastProductUpdateDate;
+            state.productSync.productsCount = productSyncData.productsCount;
+            const mainSettingsData = action.payload.data.mainSettings;
+            state.mainSettings.siteStatus = mainSettingsData.siteStatus;
+            // a sync on demand has started, show message that sync has started
+            if (state.productSync.syncProgressCounter === SYNC_PROGRESS_UPDATES_NUM) {
+                state.productSync.syncMessage = syncStartedMessage;
+            }
+            if (state.productSync.syncProgressCounter > 0) {
+                state.productSync.syncProgressCounter =
+                    state.productSync.syncProgressCounter - 1;
+            }
+        });
+        builder.addCase(startSyncOnDemandShopify.pending, (state, action) => {
+            //state.productSync.syncButtonText = 'Syncing...';
+            state.productSync.syncMessage = syncStartedMessage;
+            state.productSync.isSyncButtonLoading = true;
+        });
+        builder.addCase(startSyncOnDemandShopify.rejected, (state, action) => {
+            state.productSync.syncButtonText = syncNowMessage;
+            state.productSync.syncMessage = syncErrorMessage;
+            state.productSync.isSyncButtonLoading = false;
+        });
+        builder.addCase(startSyncOnDemandShopify.fulfilled, (state, action) => {
+            state.productSync.isSyncButtonLoading = false;
+            const success = action.payload.data['success'];
+            if (!success) {
+                state.productSync.syncMessage = syncErrorMessage;
+            }
+        });
+        builder.addCase(startSyncOnDemand.pending, (state, action) => {
+            //state.productSync.syncButtonText = 'Syncing...';
+            state.productSync.isSyncButtonLoading = true;
+            state.productSync.syncMessage = syncStartedMessage;
+        });
+        builder.addCase(startSyncOnDemand.rejected, (state, action) => {
+            state.productSync.syncButtonText = syncNowMessage;
+            state.productSync.syncMessage = syncErrorMessage;
+            state.productSync.isSyncButtonLoading = false;
+        });
+        builder.addCase(startSyncOnDemand.fulfilled, (state, action) => {
+            state.productSync.isSyncButtonLoading = false;
+            const success = action.payload.data['success'];
+            if (!success) {
+                state.productSync.syncMessage = syncErrorMessage;
+            }
+        });
+        builder.addCase(setEnableProducts.pending, (state, action) => {
+            state.productSync.isProductsEnabled = !state.productSync.isProductsEnabled;
+        });
+        builder.addCase(setEnableProducts.rejected, (state, action) => {
+            state.productSync.isProductsEnabled = !state.productSync.isProductsEnabled;
+        });
+        builder.addCase(setEnableProducts.fulfilled, (state, action) => {
+            const success = action.payload;
+            if (!success) {
+                state.productSync.isProductsEnabled = !state.productSync.isProductsEnabled;
+                // TODO:: show error message
+            }
+        });
+        builder.addCase(getWooSyncWarnings.pending, (state, action) => {
+            state.syncWarnings.isLoading = true;
+            state.syncWarnings.woocommerceWarnings.data = {};
+            state.syncWarnings.errorStatus = '';
+        });
+        builder.addCase(getWooSyncWarnings.rejected, (state, action) => {
+            state.syncWarnings.isLoading = false;
+            state.syncWarnings.errorStatus = action.error.message;
+        });
+        builder.addCase(getWooSyncWarnings.fulfilled, (state, action) => {
+            state.syncWarnings.isLoading = false;
+            if (action.payload.data.errorStatus) {
+                state.syncWarnings.errorStatus = action.payload.data.errorStatus;
+            }
+            if (action.payload.data.errorMessage) {
+                state.syncWarnings.woocommerceWarnings.errorMessage = action.payload.data.errorMessage;
+            }
+            if (action.payload.data.warningsData) {
+                state.syncWarnings.woocommerceWarnings.data = action.payload.data.warningsData;
+            }
+        });
+        builder.addCase(getBigcommerceSyncWarnings.pending, (state, action) => {
+            state.syncWarnings.isLoading = true;
+            state.syncWarnings.bigcommerceWarnings.serpConflictMessage = '';
+            state.syncWarnings.errorStatus = '';
+        });
+        builder.addCase(getBigcommerceSyncWarnings.rejected, (state, action) => {
+            state.syncWarnings.isLoading = false;
+            state.syncWarnings.errorStatus = action.error.message;
+        });
+        builder.addCase(getBigcommerceSyncWarnings.fulfilled, (state, action) => {
+            state.syncWarnings.isLoading = false;
+            if (action.payload.data.errorStatus) {
+                state.syncWarnings.errorStatus = action.payload.data.errorStatus;
+            }
+            else {
+                if (action.payload.data.serpConflictMessage) {
+                    state.syncWarnings.bigcommerceWarnings.serpConflictMessage =
+                        action.payload.data.serpConflictMessage;
+                }
+                if (action.payload.data.lastProductUpdateDate) {
+                    state.syncWarnings.lastProductUpdateDate =
+                        action.payload.data.lastProductUpdateDate;
+                }
+            }
+        });
+        builder.addCase(setSyncOption.pending, (state, action) => {
+            onSetSyncOptionPending(state, action);
+        });
+        builder.addCase(setSyncOption.rejected, (state, action) => {
+            onSetSyncOptionRejected(state, action);
+        });
+        builder.addCase(setSyncOption.fulfilled, (state, action) => {
+            onSetSyncOptionFulfilled(state, action);
+        });
+        builder.addCase(setSkuSyncOption.pending, (state, action) => {
+            onSetSyncOptionPending(state, action);
+        });
+        builder.addCase(setSkuSyncOption.rejected, (state, action) => {
+            onSetSyncOptionRejected(state, action);
+        });
+        builder.addCase(setSkuSyncOption.fulfilled, (state, action) => {
+            onSetSyncOptionFulfilled(state, action);
+        });
+        builder.addCase(setDescSyncOption.pending, (state, action) => {
+            onSetSyncOptionPending(state, action);
+        });
+        builder.addCase(setDescSyncOption.rejected, (state, action) => {
+            onSetSyncOptionRejected(state, action);
+        });
+        builder.addCase(setDescSyncOption.fulfilled, (state, action) => {
+            onSetSyncOptionFulfilled(state, action);
+        });
+        builder.addCase(setCustomAttr.pending, (state, action) => {
+            state.customAttr.isSaving = true;
+            state.customAttr.isSaveError = false;
+        });
+        builder.addCase(setCustomAttr.rejected, (state, action) => {
+            state.customAttr.isSaving = false;
+            state.customAttr.isSaveError = true;
+            state.customAttr.tempValues = state.customAttr.values;
+        });
+        builder.addCase(setCustomAttr.fulfilled, (state, action) => {
+            const success = action.payload.data.success;
+            state.customAttr.isSaving = false;
+            state.customAttr.isSaveError = !success;
+            if (success) {
+                state.customAttr.values = action.meta.arg;
+                state.customAttr.errorMessage = '';
+                state.customAttr.values = state.customAttr.tempValues;
+            }
+            else {
+                state.customAttr.errorMessage = action.payload.data.errorMessage;
+                state.customAttr.tempValues = state.customAttr.values;
+            }
+        });
+        builder.addCase(setVariantOptions.pending, (state, action) => {
+            state.variantOptions.isSaving = true;
+            state.variantOptions.isSaveError = false;
+        });
+        builder.addCase(setVariantOptions.rejected, (state, action) => {
+            state.variantOptions.isSaving = false;
+            state.variantOptions.isSaveError = true;
+        });
+        builder.addCase(setVariantOptions.fulfilled, (state, action) => {
+            const success = action.payload.data.success;
+            state.variantOptions.isSaving = false;
+            state.variantOptions.isSaveError = !success;
+            if (success) {
+                state.variantOptions.values = action.meta.arg;
+            }
+        });
+        builder.addCase(setProductsAttributeMetafields.pending, (state, action) => {
+            state.productsAttributeMetafields.errorMessage = '';
+            state.productsAttributeMetafields.isSaving = true;
+            state.productsAttributeMetafields.isSaveError = false;
+        });
+        builder.addCase(setProductsAttributeMetafields.rejected, (state, action) => {
+            state.productsAttributeMetafields.isSaving = false;
+            state.productsAttributeMetafields.isSaveError = true;
+            state.productsAttributeMetafields.values = state.productsAttributeMetafields.savedValues;
+            state.productsAttributeMetafields.errorMessage = serverErrorMessage;
+        });
+        builder.addCase(setProductsAttributeMetafields.fulfilled, (state, action) => {
+            const success = action.payload.data.success;
+            state.productsAttributeMetafields.isSaving = false;
+            state.productsAttributeMetafields.isSaveError = !success;
+            if (success) {
+                state.productsAttributeMetafields.values = action.meta.arg;
+                state.productsAttributeMetafields.errorMessage = '';
+                state.productsAttributeMetafields.savedValues = state.productsAttributeMetafields.values;
+            }
+            else {
+                state.productsAttributeMetafields.errorMessage = action.payload.data.errorMessage;
+                state.productsAttributeMetafields.values = state.productsAttributeMetafields.savedValues;
+            }
+        });
+        builder.addCase(setVariantsAttributeMetafields.pending, (state, action) => {
+            state.variantsAttributeMetafields.errorMessage = '';
+            state.variantsAttributeMetafields.isSaving = true;
+            state.variantsAttributeMetafields.isSaveError = false;
+        });
+        builder.addCase(setVariantsAttributeMetafields.rejected, (state, action) => {
+            state.variantsAttributeMetafields.isSaving = false;
+            state.variantsAttributeMetafields.isSaveError = true;
+            state.variantsAttributeMetafields.values = state.variantsAttributeMetafields.savedValues;
+            state.variantsAttributeMetafields.errorMessage = serverErrorMessage;
+        });
+        builder.addCase(setVariantsAttributeMetafields.fulfilled, (state, action) => {
+            const success = action.payload.data.success;
+            state.variantsAttributeMetafields.isSaving = false;
+            state.variantsAttributeMetafields.isSaveError = !success;
+            if (success) {
+                state.variantsAttributeMetafields.values = action.meta.arg;
+                state.variantsAttributeMetafields.errorMessage = '';
+                state.variantsAttributeMetafields.savedValues = state.variantsAttributeMetafields.values;
+            }
+            else {
+                state.variantsAttributeMetafields.errorMessage = action.payload.data.errorMessage;
+                state.variantsAttributeMetafields.values = state.variantsAttributeMetafields.savedValues;
+            }
+        });
+        builder.addCase(setNonSellableProducts.pending, (state, action) => {
+            const isShow = action.meta.arg.isShow;
+            const isDemote = action.meta.arg.isDemote;
+            state.nonSellableProducts.isShow = isShow;
+            state.nonSellableProducts.isDemote = isDemote;
+        });
+        builder.addCase(setNonSellableProducts.rejected, (state, action) => {
+            const isShowOld = action.meta.arg.isShowOld;
+            const isDemoteOld = action.meta.arg.isDemoteOld;
+            state.nonSellableProducts.isShow = isShowOld;
+            state.nonSellableProducts.isDemote = isDemoteOld;
+        });
+        builder.addCase(setNonSellableProducts.fulfilled, (state, action) => {
+            const success = action.payload.data.success;
+            if (!success) {
+                const isShowOld = action.meta.arg.isShowOld;
+                const isDemoteOld = action.meta.arg.isDemoteOld;
+                state.nonSellableProducts.isShow = isShowOld;
+                state.nonSellableProducts.isDemote = isDemoteOld;
+            }
+        });
+        builder.addCase(setProductImageSource.pending, (state, action) => {
+            state.shProductImageSource = toggleProductImageSource(state.shProductImageSource);
+        });
+        builder.addCase(setProductImageSource.rejected, (state, action) => {
+            state.shProductImageSource = toggleProductImageSource(state.shProductImageSource);
+        });
+        builder.addCase(setProductImageSource.fulfilled, (state, action) => {
+            const success = action.payload.data.success;
+            if (!success) {
+                state.shProductImageSource = toggleProductImageSource(state.shProductImageSource);
+            }
+        });
+        builder.addCase(setProductCreationDateSource.pending, (state, action) => {
+            state.shProductCreationDateSource.source = action.meta.arg.source;
+            state.shProductCreationDateSource.metafield = action.meta.arg.metafield;
+        });
+        builder.addCase(setProductCreationDateSource.rejected, (state, action) => {
+            state.shProductCreationDateSource.source = action.meta.arg.oldSource;
+            state.shProductCreationDateSource.metafield = action.meta.arg.oldMetafield;
+        });
+        builder.addCase(setProductCreationDateSource.fulfilled, (state, action) => {
+            const success = action.payload.data.success;
+            if (!success) {
+                state.shProductCreationDateSource.source = action.meta.arg.oldSource;
+                state.shProductCreationDateSource.metafield = action.meta.arg.oldMetafield;
+            }
+            else {
+                state.shProductCreationDateSource.oldSource = action.meta.arg.source;
+                state.shProductCreationDateSource.oldMetafield = action.meta.arg.metafield;
+            }
+        });
+        builder.addCase(setHideProducts.pending, (state, action) => {
+            const avoidType = action.meta.arg.avoidType;
+            state.hideProducts.isSaving[avoidType] = true;
+            state.hideProducts.isSaveError[avoidType] = false;
+        });
+        builder.addCase(setHideProducts.rejected, (state, action) => {
+            const avoidType = action.meta.arg.avoidType;
+            state.hideProducts.isSaving[avoidType] = false;
+            state.hideProducts.isSaveError[avoidType] = true;
+        });
+        builder.addCase(setHideProducts.fulfilled, (state, action) => {
+            const success = action.payload.data.success;
+            const avoidValues = action.meta.arg.avoidValues;
+            const avoidType = action.meta.arg.avoidType;
+            state.hideProducts.isSaving[avoidType] = false;
+            state.hideProducts.isSaveError[avoidType] = !success;
+            if (avoidType === AVOID_TYPE.AVOID_PRODUCTS_WITH_TAGS) {
+                state.hideProducts.avoidProductsWithTags = avoidValues;
+            }
+            else if (avoidType === AVOID_TYPE.AVOID_PRODUCTS_WITH_METAFIELDS) {
+                state.hideProducts.avoidProductsWithMetafields = avoidValues;
+            }
+            else if (avoidType === AVOID_TYPE.AVOID_VARIANTS_WITH_METAFIELDS) {
+                state.hideProducts.avoidVariantsWithMetafields = avoidValues;
+            }
+        });
+        builder.addCase(setExcludeTagsFromSync.pending, (state, action) => {
+            state.excludeTagsFromSync.isSaving = true;
+            state.excludeTagsFromSync.isSaveError = false;
+        });
+        builder.addCase(setExcludeTagsFromSync.rejected, (state, action) => {
+            state.excludeTagsFromSync.isSaving = false;
+            state.excludeTagsFromSync.isSaveError = true;
+        });
+        builder.addCase(setExcludeTagsFromSync.fulfilled, (state, action) => {
+            state.excludeTagsFromSync.isSaving = false;
+            state.excludeTagsFromSync.isSaveError = false;
+            state.excludeTagsFromSync.tags = action.meta.arg;
+        });
+        builder.addCase(checkSiteState.fulfilled, (state, action) => {
+            const success = action.payload.success;
+            if (!success) {
+                return;
+            }
+            //update info from the Magento extension
+            if ('isFlatProductsEnabled' in action.payload) {
+                state.magentoInfo.isFlatProductsEnabled = action.payload.isFlatProductsEnabled;
+            }
+            //TODO: fetch the info of the WooCommerce ext. in this handler as well,
+            // and not in the general fetch settings handler
+        });
+        builder.addCase(saveSiteGroupUserPassword.pending, (state, action) => {
+            state.editSettings.userPasswordValidateMessage = '';
+            state.editSettings.isUserPasswordValid = false;
+            state.editSettings.isUserPasswordLoading = true;
+        });
+        builder.addCase(saveSiteGroupUserPassword.rejected, (state, action) => {
+            state.editSettings.isUserPasswordLoading = false;
+        });
+        builder.addCase(saveSiteGroupUserPassword.fulfilled, (state, action) => {
+            const success = action.payload.data.success;
+            if (success) {
+            }
+            state.editSettings.isUserPasswordLoading = false;
+        });
+        builder.addCase(validateSiteGroupUserPassword.pending, (state, action) => {
+            state.editSettings.isUserPasswordValid = false;
+            state.editSettings.userPasswordValidateMessage = 'Getting Authentication...';
+        });
+        builder.addCase(validateSiteGroupUserPassword.rejected, (state, action) => {
+            state.editSettings.userPasswordValidateMessage = 'Cannot Get Authentication.';
+        });
+        builder.addCase(validateSiteGroupUserPassword.fulfilled, (state, action) => {
+            const success = action.payload.data.success;
+            state.editSettings.isUserPasswordValid = success;
+            state.editSettings.userPasswordValidateMessage = success ?
+                'Authentication Verified :-)' : 'Wrong Authentication :-(';
+        });
+        builder.addCase(getHowIpsSeesProduct.pending, (state, action) => {
+            state.howIspSees.isLoading = true;
+            state.howIspSees.isResultError = false;
+        });
+        builder.addCase(getHowIpsSeesProduct.rejected, (state, action) => {
+            state.howIspSees.isLoading = false;
+            state.howIspSees.isResultError = true;
+        });
+        builder.addCase(getHowIpsSeesProduct.fulfilled, (state, action) => {
+            state.howIspSees.isLoading = false;
+            const success = action.payload.data.success;
+            if (!success || !action.payload.data.result) {
+                state.howIspSees.isResultError = true;
+            }
+            const result = action.payload.data.result;
+            state.howIspSees.result.status = result.status;
+            if (result.errorMessage) {
+                state.howIspSees.result.errorMessage = result.errorMessage;
+            }
+            if (result.fewProducts) {
+                state.howIspSees.result.fewProducts = result.fewProducts;
+                return;
+            }
+            state.howIspSees.result.isUseCustomAttr2ForSite = result.isUseCustomAttr2ForSite;
+            state.howIspSees.result.isShowNonSellableProducts = result.isShowNonSellableProducts;
+            if (result.productInfos) {
+                state.howIspSees.result.productInfos = result.productInfos;
+            }
+            if (result.product) {
+                const product = result.product;
+                state.howIspSees.result.product = product;
+                state.howIspSees.result.product.customAttrNames2 = JSON.stringify(product.customAttrNames2);
+                if (product.attributes) {
+                    state.howIspSees.result.product.attributes = product.attributes;
+                }
+                if (product.categoryList) {
+                    state.howIspSees.result.product.categoryList = product.categoryList;
+                }
+                state.howIspSees.result.product.sourceCreationDate = product.sourceCreationDate;
+                state.howIspSees.result.product.reviewsScore = product.reviewsScore;
+                state.howIspSees.result.product.reviewsCount = product.reviewsCount;
+            }
+        });
+        builder.addCase(saveRestrictedAdmin.pending, (state, action) => {
+            state.restrictedAdmins.isLoading = true;
+            state.restrictedAdmins.errorMessages.email = '';
+            state.restrictedAdmins.errorMessages.general = '';
+        });
+        builder.addCase(saveRestrictedAdmin.rejected, (state, action) => {
+            state.restrictedAdmins.isLoading = false;
+            state.restrictedAdmins.errorMessages['general'] = adminSaveErrorMessage;
+        });
+        builder.addCase(saveRestrictedAdmin.fulfilled, (state, action) => {
+            state.restrictedAdmins.isLoading = false;
+            const errorType = action.payload.data.errorType;
+            const errorMessage = action.payload.data.message;
+            if (!action.payload.data.success) {
+                state.restrictedAdmins.errorMessages[errorType] = errorMessage;
+                return;
+            }
+            else {
+                state.restrictedAdmins.errorMessages['email'] = '';
+                state.restrictedAdmins.errorMessages['general'] = '';
+            }
+            const editedAdmin = state.restrictedAdmins.editedAdmin;
+            const index = editedAdmin.index;
+            if (index < state.restrictedAdmins.admins.length) {
+                //edit an existing admin:
+                state.restrictedAdmins.admins[index].email = editedAdmin.email;
+                state.restrictedAdmins.admins[index].roles = editedAdmin.roles;
+                state.restrictedAdmins.admins[index].sites = editedAdmin.sites;
+            }
+            else {
+                //add a new admin
+                const newAdmin = {
+                    email: editedAdmin.email,
+                    roles: editedAdmin.roles,
+                    sites: editedAdmin.sites
+                };
+                state.restrictedAdmins.admins.push(newAdmin);
+            }
+            state.restrictedAdmins.editedAdmin.isSaveGood = true;
+            state.restrictedAdmins.errorMessages[errorType] = errorMessage;
+        });
+        builder.addCase(deleteRestrictedAdmin.pending, (state, action) => {
+            state.restrictedAdmins.isLoading = true;
+        });
+        builder.addCase(deleteRestrictedAdmin.rejected, (state, action) => {
+            state.restrictedAdmins.isLoading = false;
+        });
+        builder.addCase(deleteRestrictedAdmin.fulfilled, (state, action) => {
+            state.restrictedAdmins.isLoading = false;
+            const index = state.restrictedAdmins.editedAdmin.index;
+            //delete this admin
+            state.restrictedAdmins.admins.splice(index, 1);
+        });
+        builder.addCase(uploadCsvToBlob.pending, (state, action) => {
+            state.customCsvInfo.isUploading = true;
+        });
+        builder.addCase(uploadCsvToBlob.rejected, (state, action) => {
+            state.customCsvInfo.isUploading = false;
+        });
+        builder.addCase(uploadCsvToBlob.fulfilled, (state, action) => {
+        });
+        builder.addCase(getUploadCsvStatus.pending, (state, action) => {
+        });
+        builder.addCase(setProductImageOptimization.pending, (state, action) => {
+            state.productImageOptimization.productImageOptimization = action.meta.arg.value;
+        });
+        builder.addCase(getUploadCsvStatus.rejected, (state, action) => {
+            state.customCsvInfo.isUploading = false;
+        });
+        builder.addCase(getUploadCsvStatus.fulfilled, (state, action) => {
+            state.customCsvInfo.isUploading = false;
+            const success = action.payload.data.success;
+            if (success) {
+                const result = action.payload.data.result;
+                state.customCsvInfo.csvUploadStatus = result.csvUploadStatus;
+                state.customCsvInfo.isCsvUploaded = result.isCsvUploaded;
+                state.customCsvInfo.csvUploadMessage = result.csvUploadMessage;
+                state.customCsvInfo.timeToComplete = result.timeToComplete;
+                if (result.csvUploadMessage &&
+                    result.csvUploadMessage.indexOf('progress') >= 0) {
+                    state.customCsvInfo.csvUploadMessage = syncInProgressMessage;
+                }
+                if (result.csvUploadStatus === 'SUCCESS' && !result.timeToComplete) {
+                    state.customCsvInfo.timeToComplete = TIME_MS.MINUTE * 7;
+                }
+            }
+            else {
+                state.customCsvInfo.csvUploadMessage = 'An error occurred, please try again.';
+            }
+        });
+        builder.addCase(setPricingStringInput.pending, (state, action) => {
+            state.pricingStringFields[action.meta.arg.optionName] = action.meta.arg.optionValue;
+        });
+        builder.addCase(setPricingSwitch.pending, (state, action) => {
+            state.pricingBooleanFields[action.meta.arg.optionName] = action.meta.arg.optionValue;
+        });
+        builder.addCase(setPricingSwitch.rejected, (state, action) => {
+            state.pricingBooleanFields[action.meta.arg.optionName] = !state.pricingBooleanFields[action.meta.arg.optionName];
+        });
+        builder.addCase(updateIpAddresses.pending, (state, action) => {
+            state.updateIpAddresses.isLoading = true;
+            state.updateIpAddresses.isError = false;
+            state.updateIpAddresses.updateMessage = '';
+        });
+        builder.addCase(updateIpAddresses.rejected, (state, action) => {
+            state.updateIpAddresses.isLoading = false;
+            state.updateIpAddresses.isError = true;
+            state.updateIpAddresses.updateMessage = 'An error has occurred, please try again';
+        });
+        builder.addCase(updateIpAddresses.fulfilled, (state, action) => {
+            state.updateIpAddresses.isLoading = false;
+            state.updateIpAddresses.isError = !action.payload.isSuccess;
+            state.updateIpAddresses.updateMessage = action.payload.errorMessage;
+            state.updateIpAddresses.excludedIpAddresses = action.meta.arg;
+        });
+        builder.addCase(fetchLocations.fulfilled, (state, action) => {
+            state.locationsData = {
+                isLoading: false,
+                syncedLocations: action.payload.syncedLocations,
+                locations: action.payload.locations,
+                isReadInventoryPlatformPermission: action.payload.isReadInventoryPlatformPermission
+            };
+        });
+        builder.addCase(updateLocations.pending, (state, action) => {
+            state.locationsData.syncedLocations = action.meta.arg.syncedLocations;
+        });
+        builder.addCase(setTagManagerProvider.pending, (state, action) => {
+            state.tagManagerProvider.isLoading = true;
+        });
+        builder.addCase(setTagManagerProvider.rejected, (state, action) => {
+            state.tagManagerProvider.isLoading = false;
+        });
+        builder.addCase(setTagManagerProvider.fulfilled, (state, action) => {
+            state.tagManagerProvider.isLoading = false;
+            const success = action.payload.data['success'];
+            if (!success) {
+                state.tagManagerProvider.systemErrorMsg = syncErrorMessage;
+                return;
+            }
+            state.tagManagerProvider.tagManagerProvider = action.meta.arg.tagManagerProvider;
+        });
+    },
+});
+function onSetSyncOptionPending(state, action) {
+    const optionName = action.meta.arg.optionName;
+    const optionValue = action.meta.arg.optionValue;
+    state.syncOptions[optionName] = optionValue;
+}
+function onSetSyncOptionRejected(state, action) {
+    const optionName = action.meta.arg.optionName;
+    const optionValue = action.meta.arg.optionValue;
+    state.syncOptions[optionName] = !optionValue;
+}
+function onSetSyncOptionFulfilled(state, action) {
+    const payload = action.payload;
+    const success = payload.data.success;
+    const optionName = action.meta.arg.optionName;
+    const optionValue = action.meta.arg.optionValue;
+}
+export const selectCurrentSiteKey = (state) => state.sync.currentSiteKey;
+export const selectMainSettings = (state) => state.sync.mainSettings;
+export const selectEditSettings = (state) => state.sync.editSettings;
+export const selectMagentoInfo = (state) => state.sync.magentoInfo;
+export const selectWoocommerceInfo = (state) => state.sync.woocommerceInfo;
+export const selectCustomCsvInfo = (state) => state.sync.customCsvInfo;
+export const selectProductSync = (state) => state.sync.productSync;
+export const selectSyncWarnings = (state) => state.sync.syncWarnings;
+export const selectSyncOptions = (state) => state.sync.syncOptions;
+export const selectIsSyncSettingsLoading = (state) => state.sync.loading.settings;
+export const selectSyncLoading = (state) => state.sync.loading;
+export const selectSyncError = (state) => state.sync.error;
+export const selectCustomAttr = (state) => state.sync.customAttr.values;
+export const selectCustomTempAttr = (state) => state.sync.customAttr.tempValues;
+export const selectCustomAttrOptions = (state) => state.sync.customAttr.options;
+export const selectCustomAttrIsSaving = (state) => state.sync.customAttr.isSaving;
+export const selectCustomAttrIsError = (state) => state.sync.customAttr.isSaveError;
+export const selectCustomAttrErrorMsg = (state) => state.sync.customAttr.errorMessage;
+export const selectVariantOptions = (state) => state.sync.variantOptions;
+export const selectNonSellableProducts = (state) => state.sync.nonSellableProducts;
+export const selectProductImageSource = (state) => state.sync.shProductImageSource;
+export const selectProductCreationDateSource = (state) => state.sync.shProductCreationDateSource;
+export const selectAllDateProductsMetafields = (state) => state.sync.allDateProductsMetafields;
+export const selectAllProductsMetafields = (state) => state.sync.allProductsMetafields;
+export const selectAllVariantsMetafields = (state) => state.sync.allVariantsMetafields;
+export const selectProductsAttributeMetafields = (state) => state.sync.productsAttributeMetafields;
+export const selectVariantsAttributeMetafields = (state) => state.sync.variantsAttributeMetafields;
+export const selectHideProducts = (state) => state.sync.hideProducts;
+export const selectExcludeTagsFromSync = (state) => state.sync.excludeTagsFromSync;
+export const selectHowIspSees = (state) => state.sync.howIspSees;
+export const selectRestrictedAdmins = (state) => state.sync.restrictedAdmins;
+export const selectProductImageOptimization = (state) => state.sync.productImageOptimization.productImageOptimization;
+export const selectPricingBooleanFields = (state) => state.sync.pricingBooleanFields;
+export const selectPricingStringFields = (state) => state.sync.pricingStringFields;
+export const selectUpdateIpAddresses = (state) => state.sync.updateIpAddresses;
+export const selectLocations = (state) => state.sync.locationsData;
+export default syncSlice.reducer;
+export const setInitialSiteStatus = syncSlice.actions.setInitialSiteStatus;
+export const changeCurrentSite = syncSlice.actions.changeCurrentSite;
+export const setSyncMessage = syncSlice.actions.setSyncMessage;
+export const setSyncMessageTimeout = syncSlice.actions.setSyncMessageTimeout;
+export const setSyncProgressTimeout = syncSlice.actions.setSyncProgressTimeout;
+export const setCustomAttrErrorMessage = syncSlice.actions.setCustomAttrErrorMessage;
+export const setCustomAttributesTemp = syncSlice.actions.setCustomAttributesTemp;
+export const setVariantOptionsTemp = syncSlice.actions.setVariantOptionsTemp;
+export const setProductsAttributeMetafieldsErrorMessage = syncSlice.actions.setProductsAttributeMetafieldsErrorMessage;
+export const setVariantsAttributeMetafieldsErrorMessage = syncSlice.actions.setVariantsAttributeMetafieldsErrorMessage;
+export const setProductsAttributeMetafieldsTemp = syncSlice.actions.setProductsAttributeMetafieldsTemp;
+export const setVariantsAttributeMetafieldsTemp = syncSlice.actions.setVariantsAttributeMetafieldsTemp;
+export const setHideProductsTemp = syncSlice.actions.setHideProductsTemp;
+export const setSiteGroupUserPassword = syncSlice.actions.setSiteGroupUserPassword;
+export const setHowIspSeesProductName = syncSlice.actions.setHowIspSeesProductName;
+export const setEditedRestrictedAdmin = syncSlice.actions.setEditedRestrictedAdmin;
+export const resetEditedRestrictedAdmin = syncSlice.actions.resetEditedRestrictedAdmin;
+export const setRestrictedAdminErrorMessage = syncSlice.actions.setRestrictedAdminErrorMessage;
+export const clearRestrictedAdminErrorMessage = syncSlice.actions.clearRestrictedAdminErrorMessage;
+export const setEditedRestrictedProp = syncSlice.actions.setEditedRestrictedProp;
+export const setCsvUploadFileName = syncSlice.actions.setCsvUploadFileName;
+export const changeCustomCsvBooleanValue = syncSlice.actions.changeCustomCsvBooleanValue;
+export const setCsvUploadTimeout = syncSlice.actions.setCsvUploadTimeout;
+export const setCsvUploadMessage = syncSlice.actions.setCsvUploadMessage;
+export const setCsvUploadStatus = syncSlice.actions.setCsvUploadStatus;
+export const setCsvEncoding = syncSlice.actions.setCsvEncoding;
+export const setIsCsvUploading = syncSlice.actions.setIsCsvUploading;
+export const setCsvTimeToComplete = syncSlice.actions.setCsvTimeToComplete;
+export const setLastProductUpdateDate = syncSlice.actions.setLastProductUpdateDate;
+export const setCatalogLanguage = syncSlice.actions.setCatalogLanguage;
+export const setProductCreationDateSourceValue = syncSlice.actions.setProductCreationDateSourceValue;
+export const setProductCreationDateSourceMetafield = syncSlice.actions.setProductCreationDateSourceMetafield;
+export const setSyncProgressCounter = syncSlice.actions.setSyncProgressCounter;
+export const selectTagManagerProvider = (state) => state.sync.tagManagerProvider;
+//# sourceMappingURL=syncSlice.js.map