@open-tender/cloud 0.0.1

package/dist/esm/slices/customer/groupOrders.js

@@ -0,0 +1,143 @@
+import { __awaiter } from "tslib";
+import { createAsyncThunk, createSlice } from '@reduxjs/toolkit';
+import { ReducerType } from '../types';
+import { MISSING_CUSTOMER } from '@open-tender/types';
+import { checkAuth, selectToken } from './account';
+import { makeCartPayload } from '../groupOrder';
+import { makeSimpleCart } from '@open-tender/utils';
+const initialState = {
+    entities: [],
+    lookup: {},
+    loading: 'idle',
+    error: null
+};
+export var CustomerGroupOrdersActionType;
+(function (CustomerGroupOrdersActionType) {
+    CustomerGroupOrdersActionType["FetchCustomerGroupOrders"] = "customer/fetchCustomerGroupOrders";
+    CustomerGroupOrdersActionType["FetchCustomerGroupOrder"] = "customer/fetchCustomerGroupOrder";
+    CustomerGroupOrdersActionType["AddCustomerGroupOrder"] = "customer/addCustomerGroupOrder";
+})(CustomerGroupOrdersActionType || (CustomerGroupOrdersActionType = {}));
+export const fetchCustomerGroupOrders = createAsyncThunk(CustomerGroupOrdersActionType.FetchCustomerGroupOrders, (_, { dispatch, getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const api = getState().config.api;
+        const token = selectToken(getState());
+        if (!token)
+            throw new Error(MISSING_CUSTOMER);
+        const orders = yield api.getCustomerGroupOrders(token);
+        return orders;
+    }
+    catch (err) {
+        const error = err;
+        return checkAuth(error, dispatch, () => rejectWithValue(error));
+    }
+}));
+export const fetchCustomerGroupOrder = createAsyncThunk(CustomerGroupOrdersActionType.FetchCustomerGroupOrder, (cartId, { dispatch, getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const api = getState().config.api;
+        const token = selectToken(getState());
+        if (!token)
+            throw new Error(MISSING_CUSTOMER);
+        const response = yield api.getCustomerGroupOrder(token, cartId);
+        const payload = Object.assign(Object.assign({}, makeCartPayload(response)), { isCartOwner: true });
+        return payload;
+    }
+    catch (err) {
+        const error = err;
+        return checkAuth(error, dispatch, () => rejectWithValue(error));
+    }
+}));
+const makeCartData = (order, data = {}) => {
+    const { address, revenueCenter, requestedAt, serviceType, cart } = order;
+    const orderData = {
+        address,
+        revenue_center_id: revenueCenter === null || revenueCenter === void 0 ? void 0 : revenueCenter.revenue_center_id,
+        service_type: serviceType,
+        requested_at: requestedAt,
+        cart: makeSimpleCart(cart !== null && cart !== void 0 ? cart : []),
+        spending_limit: null
+    };
+    const { spendingLimit } = data;
+    if (spendingLimit !== undefined) {
+        delete data.spendingLimit;
+        orderData.spending_limit = isNaN(parseFloat(spendingLimit))
+            ? null
+            : parseFloat(spendingLimit).toFixed(2);
+    }
+    return Object.assign(Object.assign({}, orderData), data);
+};
+export const addCustomerGroupOrder = createAsyncThunk(CustomerGroupOrdersActionType.AddCustomerGroupOrder, (requestData, { dispatch, getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const api = getState().config.api;
+        const token = selectToken(getState());
+        if (!token)
+            throw new Error(MISSING_CUSTOMER);
+        const cartData = makeCartData(getState().order, requestData.data);
+        const response = yield api.postCustomerGroupOrder(token, cartData);
+        const customer = getState().customer.account.profile;
+        const payload = Object.assign(Object.assign({}, makeCartPayload(response)), { isCartOwner: true, cartOwner: customer });
+        if (requestData.callback)
+            requestData.callback();
+        return payload;
+    }
+    catch (err) {
+        const error = err;
+        return checkAuth(error, dispatch, () => rejectWithValue(error));
+    }
+}));
+const customerGroupOrdersSlice = createSlice({
+    name: ReducerType.GroupOrders,
+    initialState,
+    reducers: {
+        resetCustomerGroupOrders: () => initialState,
+        resetCustomerGroupOrdersError: state => {
+            state.error = null;
+            state.loading = 'idle';
+        },
+        setCustomerGroupOrders: (state, action) => {
+            state.entities = action.payload;
+            state.error = null;
+        }
+    },
+    extraReducers: builder => {
+        builder
+            .addCase(fetchCustomerGroupOrders.fulfilled, (state, action) => {
+            state.entities = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(fetchCustomerGroupOrders.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(fetchCustomerGroupOrders.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        })
+            .addCase(fetchCustomerGroupOrder.fulfilled, (state, action) => {
+            state.entities = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(fetchCustomerGroupOrder.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(fetchCustomerGroupOrder.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        })
+            .addCase(addCustomerGroupOrder.fulfilled, (state, action) => {
+            state.entities = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(addCustomerGroupOrder.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(addCustomerGroupOrder.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        });
+    }
+});
+export const { resetCustomerGroupOrders, resetCustomerGroupOrdersError, setCustomerGroupOrders } = customerGroupOrdersSlice.actions;
+export const selectCustomerGroupOrders = (state) => state.customer.groupOrders;
+export const customerGroupOrdersReducer = customerGroupOrdersSlice.reducer;

package/dist/esm/slices/customer/houseAccounts.d.ts

@@ -0,0 +1,20 @@
+import { AppState } from '../../app';
+import { HouseAccounts, RequestError, RequestStatus } from '@open-tender/types';
+export interface CustomerHouseAccountsState {
+    entities: HouseAccounts;
+    error: RequestError;
+    loading: RequestStatus;
+    lookup: {
+        [key: number]: number;
+    };
+}
+export declare enum CustomerHouseAccountsActionType {
+    FetchCustomerHouseAccounts = "customer/fetchCustomerHouseAccounts"
+}
+export declare const fetchCustomerHouseAccounts: import("@reduxjs/toolkit").AsyncThunk<HouseAccounts, void, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const resetCustomerHouseAccounts: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>, resetCustomerHouseAccountsError: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>, setCustomerHouseAccounts: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, string>;
+export declare const selectCustomerHouseAccounts: (state: AppState) => import("./orders").CustomerOrdersState;
+export declare const customerHouseAccountsReducer: import("redux").Reducer<CustomerHouseAccountsState, import("redux").AnyAction>;

package/dist/esm/slices/customer/houseAccounts.js

@@ -0,0 +1,62 @@
+import { __awaiter } from "tslib";
+import { createAsyncThunk, createSlice } from '@reduxjs/toolkit';
+import { ReducerType } from '../types';
+import { MISSING_CUSTOMER } from '@open-tender/types';
+import { checkAuth, selectToken } from './account';
+const initialState = {
+    entities: [],
+    error: null,
+    loading: 'idle',
+    lookup: {}
+};
+export var CustomerHouseAccountsActionType;
+(function (CustomerHouseAccountsActionType) {
+    CustomerHouseAccountsActionType["FetchCustomerHouseAccounts"] = "customer/fetchCustomerHouseAccounts";
+})(CustomerHouseAccountsActionType || (CustomerHouseAccountsActionType = {}));
+export const fetchCustomerHouseAccounts = createAsyncThunk(CustomerHouseAccountsActionType.FetchCustomerHouseAccounts, (_, { dispatch, getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const api = getState().config.api;
+        const token = selectToken(getState());
+        if (!token)
+            throw new Error(MISSING_CUSTOMER);
+        const houseAccounts = yield api.getCustomerHouseAccounts(token);
+        return houseAccounts;
+    }
+    catch (err) {
+        const error = err;
+        return checkAuth(error, dispatch, () => rejectWithValue(error));
+    }
+}));
+const customerHouseAccountsSlice = createSlice({
+    name: ReducerType.HouseAccounts,
+    initialState,
+    reducers: {
+        resetCustomerHouseAccounts: () => initialState,
+        resetCustomerHouseAccountsError: state => {
+            state.error = null;
+            state.loading = 'idle';
+        },
+        setCustomerHouseAccounts: (state, action) => {
+            state.entities = action.payload;
+            state.error = null;
+        }
+    },
+    extraReducers: builder => {
+        builder
+            .addCase(fetchCustomerHouseAccounts.fulfilled, (state, action) => {
+            state.entities = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(fetchCustomerHouseAccounts.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(fetchCustomerHouseAccounts.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        });
+    }
+});
+export const { resetCustomerHouseAccounts, resetCustomerHouseAccountsError, setCustomerHouseAccounts } = customerHouseAccountsSlice.actions;
+export const selectCustomerHouseAccounts = (state) => state.customer.orders;
+export const customerHouseAccountsReducer = customerHouseAccountsSlice.reducer;

package/dist/esm/slices/customer/index.d.ts

@@ -0,0 +1,29 @@
+export declare const customerReducer: import("redux").Reducer<import("redux").CombinedState<{
+    account: import("./account").AccountState;
+    allergens: import("./allergens").CustomerAllergensState;
+    addresses: import("./addresses").CustomerAddressesState;
+    communicationPreferences: import("./communicationPreferences").CustomerCommunicationPrefsState;
+    creditCards: import("./creditCards").CustomerCreditCardsState;
+    favorites: import("./favorites").CustomerFavoritesState;
+    fcmToken: import("./fcmToken").CustomerFcmTokenState;
+    giftCards: import("./giftCards").CustomerGiftCardsState;
+    orders: import("./orders").CustomerOrdersState;
+    order: import("./order").CustomerOrderState;
+    loyalty: import("./loyalty").CustomerLoyaltyState;
+    groupOrders: import("./groupOrders").CustomerGroupOrdersState;
+    houseAccounts: import("./houseAccounts").CustomerHouseAccountsState;
+    rewards: import("./rewards").CustomerRewardsState;
+    qrcode: import("./qrCode").CustomerQRCodeState;
+    thanx: import("./thanx").CustomerThanxState;
+    levelup: import("./levelup").CustomerLevelUpState;
+}>, import("redux").AnyAction>;
+export * from './account';
+export * from './allergens';
+export * from './addresses';
+export * from './communicationPreferences';
+export * from './creditCards';
+export * from './favorites';
+export * from './fcmToken';
+export * from './giftCards';
+export * from './orders';
+export * from './loyalty';

package/dist/esm/slices/customer/index.js

@@ -0,0 +1,48 @@
+import { combineReducers } from 'redux';
+import { ReducerType } from '../types';
+import { accountReducer } from './account';
+import { customerAddressesReducer } from './addresses';
+import { customerAllergensReducer } from './allergens';
+import { customerCommunicationPrefsReducer } from './communicationPreferences';
+import { customerCreditCardsReducer } from './creditCards';
+import { customerFavoritesReducer } from './favorites';
+import { customerFcmTokenReducer } from './fcmToken';
+import { customerGiftCardsReducer } from './giftCards';
+import { customerGroupOrdersReducer } from './groupOrders';
+import { customerHouseAccountsReducer } from './houseAccounts';
+import { customerLevelUpReducer } from './levelup';
+import { customerLoyaltyReducer } from './loyalty';
+import { customerOrderReducer } from './order';
+import { customerOrdersReducer } from './orders';
+import { customerQRCodeReducer } from './qrCode';
+import { customerRewardsReducer } from './rewards';
+import { customerThanxReducer } from './thanx';
+export const customerReducer = combineReducers({
+    [ReducerType.Account]: accountReducer,
+    [ReducerType.CustomerAllergens]: customerAllergensReducer,
+    [ReducerType.CustomerAddresses]: customerAddressesReducer,
+    [ReducerType.CommunicationPrefs]: customerCommunicationPrefsReducer,
+    [ReducerType.CreditCards]: customerCreditCardsReducer,
+    [ReducerType.Favorites]: customerFavoritesReducer,
+    [ReducerType.FcmToken]: customerFcmTokenReducer,
+    [ReducerType.GiftCards]: customerGiftCardsReducer,
+    [ReducerType.Orders]: customerOrdersReducer,
+    [ReducerType.Order]: customerOrderReducer,
+    [ReducerType.Loyalty]: customerLoyaltyReducer,
+    [ReducerType.GroupOrders]: customerGroupOrdersReducer,
+    [ReducerType.HouseAccounts]: customerHouseAccountsReducer,
+    [ReducerType.Rewards]: customerRewardsReducer,
+    [ReducerType.QRCode]: customerQRCodeReducer,
+    [ReducerType.Thanx]: customerThanxReducer,
+    [ReducerType.Levelup]: customerLevelUpReducer
+});
+export * from './account';
+export * from './allergens';
+export * from './addresses';
+export * from './communicationPreferences';
+export * from './creditCards';
+export * from './favorites';
+export * from './fcmToken';
+export * from './giftCards';
+export * from './orders';
+export * from './loyalty';

package/dist/esm/slices/customer/levelup.d.ts

@@ -0,0 +1,36 @@
+import { AppState } from '../../app';
+import { LevelUp, RequestError, RequestStatus } from '@open-tender/types';
+export interface CustomerLevelUpState {
+    entities: LevelUp[];
+    error: RequestError;
+    loading: RequestStatus;
+    lookup: {
+        [key: number]: number;
+    };
+}
+export declare enum CustomerLevelUpActionType {
+    FetchCustomerLevelUp = "customer/fetchCustomerLevelUp",
+    RemoveCustomerLevelUp = "customer/removeCustomerLevelUp",
+    AddCustomerLevelUp = "customer/addCustomerLevelUp"
+}
+export declare const fetchCustomerLevelUp: import("@reduxjs/toolkit").AsyncThunk<LevelUp[], void, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const removeCustomerLevelUp: import("@reduxjs/toolkit").AsyncThunk<LevelUp[], {
+    levelupConnectId: number;
+    callback?: (() => void) | undefined;
+}, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const addCustomerLevelUp: import("@reduxjs/toolkit").AsyncThunk<LevelUp[], {
+    data: LevelUp;
+    callback?: (() => void) | undefined;
+}, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const resetCustomerLevelUp: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>, setCustomerLevelUp: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, string>;
+export declare const selectCustomerLevelUp: (state: AppState) => CustomerLevelUpState;
+export declare const customerLevelUpReducer: import("redux").Reducer<CustomerLevelUpState, import("redux").AnyAction>;

package/dist/esm/slices/customer/levelup.js

@@ -0,0 +1,123 @@
+import { __awaiter } from "tslib";
+import { createAsyncThunk, createSlice } from '@reduxjs/toolkit';
+import { ReducerType } from '../types';
+import { MISSING_CUSTOMER } from '@open-tender/types';
+import { checkAuth, selectToken } from './account';
+import { showNotification } from '../notifications';
+const initialState = {
+    entities: [],
+    lookup: {},
+    loading: 'idle',
+    error: null
+};
+export var CustomerLevelUpActionType;
+(function (CustomerLevelUpActionType) {
+    CustomerLevelUpActionType["FetchCustomerLevelUp"] = "customer/fetchCustomerLevelUp";
+    CustomerLevelUpActionType["RemoveCustomerLevelUp"] = "customer/removeCustomerLevelUp";
+    CustomerLevelUpActionType["AddCustomerLevelUp"] = "customer/addCustomerLevelUp";
+})(CustomerLevelUpActionType || (CustomerLevelUpActionType = {}));
+export const fetchCustomerLevelUp = createAsyncThunk(CustomerLevelUpActionType.FetchCustomerLevelUp, (_, { dispatch, getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const api = getState().config.api;
+        const token = selectToken(getState());
+        if (!token)
+            throw new Error(MISSING_CUSTOMER);
+        const levelup = yield api.getCustomerLevelUp(token);
+        return levelup;
+    }
+    catch (err) {
+        const error = err;
+        return checkAuth(error, dispatch, () => rejectWithValue(error));
+    }
+}));
+export const removeCustomerLevelUp = createAsyncThunk(CustomerLevelUpActionType.RemoveCustomerLevelUp, (requestData, { dispatch, getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const api = getState().config.api;
+        const token = selectToken(getState());
+        if (!token)
+            throw new Error(MISSING_CUSTOMER);
+        yield api.deleteCustomerLevelUp(token, requestData.levelupConnectId);
+        dispatch(showNotification('LevelUp disconnected!'));
+        if (requestData.callback)
+            requestData.callback();
+        return [];
+    }
+    catch (err) {
+        const error = err;
+        return checkAuth(error, dispatch, () => rejectWithValue(error));
+    }
+}));
+export const addCustomerLevelUp = createAsyncThunk(CustomerLevelUpActionType.AddCustomerLevelUp, (requestData, { dispatch, getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const api = getState().config.api;
+        const token = selectToken(getState());
+        if (!token)
+            throw new Error(MISSING_CUSTOMER);
+        const response = yield api.postCustomerLevelUp(token, requestData.data);
+        dispatch(showNotification('LevelUp connected!'));
+        if (requestData.callback)
+            requestData.callback();
+        return [response];
+    }
+    catch (err) {
+        const error = err;
+        return checkAuth(error, dispatch, () => rejectWithValue(error));
+    }
+}));
+const customerLevelUpSlice = createSlice({
+    name: ReducerType.Levelup,
+    initialState,
+    reducers: {
+        resetCustomerLevelUp: () => initialState,
+        setCustomerLevelUp: (state, action) => {
+            state.entities = action.payload;
+            state.error = null;
+        },
+        resetCustomerLevelUpError: state => {
+            state.error = null;
+            state.loading = 'idle';
+        }
+    },
+    extraReducers: builder => {
+        builder
+            .addCase(fetchCustomerLevelUp.fulfilled, (state, action) => {
+            state.entities = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(fetchCustomerLevelUp.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(fetchCustomerLevelUp.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        })
+            .addCase(removeCustomerLevelUp.fulfilled, (state, action) => {
+            state.entities = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(removeCustomerLevelUp.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(removeCustomerLevelUp.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        })
+            .addCase(addCustomerLevelUp.fulfilled, (state, action) => {
+            state.entities = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(addCustomerLevelUp.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(addCustomerLevelUp.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        });
+    }
+});
+export const { resetCustomerLevelUp, setCustomerLevelUp } = customerLevelUpSlice.actions;
+export const selectCustomerLevelUp = (state) => state.customer.levelup;
+export const customerLevelUpReducer = customerLevelUpSlice.reducer;

package/dist/esm/slices/customer/loyalty.d.ts

@@ -0,0 +1,27 @@
+import { AppState } from '../../app';
+import { CustomerLoyalties, OrderType, RequestError, RequestStatus } from '@open-tender/types';
+export interface CustomerLoyaltyState {
+    entities: CustomerLoyalties;
+    error: RequestError;
+    loading: RequestStatus;
+    lookup: {
+        [key: number]: number;
+    };
+}
+export declare enum CustomerLoyaltyActionType {
+    FetchCustomerLoyalty = "customer/fetchCustomerLoyalty"
+}
+export declare const fetchCustomerLoyalty: import("@reduxjs/toolkit").AsyncThunk<CustomerLoyalties, void, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const resetCustomerLoyalty: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>, resetCustomerLoyaltyError: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>, setCustomerLoyalty: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, string>;
+export declare const selectCustomerLoyalty: (state: AppState) => CustomerLoyaltyState;
+export declare const selectCustomerLoyaltyProgram: (state: AppState) => {
+    program: import("@open-tender/types").CustomerLoyalty | null;
+    loading: RequestStatus;
+    error: RequestError;
+};
+export declare const selectCustomerPointsProgram: (orderType: OrderType) => (state: AppState) => import("@open-tender/types").CustomerLoyalty | null;
+export declare const selectCustomerPoints: (orderType: OrderType) => (state: AppState) => import("@open-tender/types").LoyaltyPoints | null;
+export declare const customerLoyaltyReducer: import("redux").Reducer<CustomerLoyaltyState, import("redux").AnyAction>;

package/dist/esm/slices/customer/loyalty.js

@@ -0,0 +1,79 @@
+import { __awaiter } from "tslib";
+import { createAsyncThunk, createSlice } from '@reduxjs/toolkit';
+import { ReducerType } from '../types';
+import { MISSING_CUSTOMER } from '@open-tender/types';
+import { checkAuth, selectToken } from './account';
+const initialState = {
+    entities: [],
+    error: null,
+    loading: 'idle',
+    lookup: {}
+};
+export var CustomerLoyaltyActionType;
+(function (CustomerLoyaltyActionType) {
+    CustomerLoyaltyActionType["FetchCustomerLoyalty"] = "customer/fetchCustomerLoyalty";
+})(CustomerLoyaltyActionType || (CustomerLoyaltyActionType = {}));
+export const fetchCustomerLoyalty = createAsyncThunk(CustomerLoyaltyActionType.FetchCustomerLoyalty, (_, { dispatch, getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const api = getState().config.api;
+        const token = selectToken(getState());
+        if (!token)
+            throw new Error(MISSING_CUSTOMER);
+        const loyalty = yield api.getCustomerLoyalty(token);
+        return loyalty;
+    }
+    catch (err) {
+        const error = err;
+        return checkAuth(error, dispatch, () => rejectWithValue(error));
+    }
+}));
+const customerLoyaltySlice = createSlice({
+    name: ReducerType.Loyalty,
+    initialState,
+    reducers: {
+        resetCustomerLoyalty: () => initialState,
+        resetCustomerLoyaltyError: state => {
+            state.error = null;
+            state.loading = 'idle';
+        },
+        setCustomerLoyalty: (state, action) => {
+            state.entities = action.payload;
+            state.error = null;
+        }
+    },
+    extraReducers: builder => {
+        builder
+            .addCase(fetchCustomerLoyalty.fulfilled, (state, action) => {
+            state.entities = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(fetchCustomerLoyalty.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(fetchCustomerLoyalty.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        });
+    }
+});
+export const { resetCustomerLoyalty, resetCustomerLoyaltyError, setCustomerLoyalty } = customerLoyaltySlice.actions;
+export const selectCustomerLoyalty = (state) => state.customer.loyalty;
+export const selectCustomerLoyaltyProgram = (state) => {
+    const { entities, loading, error } = state.customer.loyalty;
+    const programs = entities.filter(i => (i.loyalty_type === 'CREDIT' || i.loyalty_type === 'POINTS') &&
+        (i.spend.order_type === null || i.spend.order_type === 'OLO'));
+    const program = programs.length ? programs[0] : null;
+    return { program, loading, error };
+};
+export const selectCustomerPointsProgram = (orderType) => (state) => {
+    const { loyalty } = state.customer;
+    const programs = loyalty.entities.filter(i => i.loyalty_type === 'POINTS' &&
+        (i.spend.order_type === null || i.spend.order_type === orderType));
+    return programs.length ? programs[0] : null;
+};
+export const selectCustomerPoints = (orderType) => (state) => {
+    const program = selectCustomerPointsProgram(orderType)(state);
+    return program ? program.points : null;
+};
+export const customerLoyaltyReducer = customerLoyaltySlice.reducer;

package/dist/esm/slices/customer/order.d.ts

@@ -0,0 +1,25 @@
+import { AppState } from '../../app';
+import { Order, OrderRating, RequestError, RequestStatus } from '@open-tender/types';
+export interface CustomerOrderState {
+    entity: Order | Partial<Order>;
+    error: RequestError;
+    loading: RequestStatus;
+}
+export declare enum CustomerOrderActionType {
+    FetchCustomerOrder = "customer/fetchCustomerOrder",
+    UpdateCustomerFavorite = "customer/updateCustomerFavorite"
+}
+export declare const fetchCustomerOrder: import("@reduxjs/toolkit").AsyncThunk<Order, number, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const updateCustomerOrderRating: import("@reduxjs/toolkit").AsyncThunk<void, {
+    orderId: number;
+    data: OrderRating;
+}, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const resetCustomerOrder: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>, resetCustomerOrderError: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>, setCustomerOrder: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, string>;
+export declare const selectCustomerOrder: (state: AppState) => CustomerOrderState;
+export declare const customerOrderReducer: import("redux").Reducer<CustomerOrderState, import("redux").AnyAction>;