@open-tender/cloud 0.0.1

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

@@ -0,0 +1,128 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.customerLevelUpReducer = exports.selectCustomerLevelUp = exports.setCustomerLevelUp = exports.resetCustomerLevelUp = exports.addCustomerLevelUp = exports.removeCustomerLevelUp = exports.fetchCustomerLevelUp = exports.CustomerLevelUpActionType = void 0;
+const tslib_1 = require("tslib");
+const toolkit_1 = require("@reduxjs/toolkit");
+const types_1 = require("../types");
+const types_2 = require("@open-tender/types");
+const account_1 = require("./account");
+const notifications_1 = require("../notifications");
+const initialState = {
+    entities: [],
+    lookup: {},
+    loading: 'idle',
+    error: null
+};
+var CustomerLevelUpActionType;
+(function (CustomerLevelUpActionType) {
+    CustomerLevelUpActionType["FetchCustomerLevelUp"] = "customer/fetchCustomerLevelUp";
+    CustomerLevelUpActionType["RemoveCustomerLevelUp"] = "customer/removeCustomerLevelUp";
+    CustomerLevelUpActionType["AddCustomerLevelUp"] = "customer/addCustomerLevelUp";
+})(CustomerLevelUpActionType = exports.CustomerLevelUpActionType || (exports.CustomerLevelUpActionType = {}));
+exports.fetchCustomerLevelUp = (0, toolkit_1.createAsyncThunk)(CustomerLevelUpActionType.FetchCustomerLevelUp, (_, { dispatch, getState, rejectWithValue }) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const api = getState().config.api;
+        const token = (0, account_1.selectToken)(getState());
+        if (!token)
+            throw new Error(types_2.MISSING_CUSTOMER);
+        const levelup = yield api.getCustomerLevelUp(token);
+        return levelup;
+    }
+    catch (err) {
+        const error = err;
+        return (0, account_1.checkAuth)(error, dispatch, () => rejectWithValue(error));
+    }
+}));
+exports.removeCustomerLevelUp = (0, toolkit_1.createAsyncThunk)(CustomerLevelUpActionType.RemoveCustomerLevelUp, (requestData, { dispatch, getState, rejectWithValue }) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const api = getState().config.api;
+        const token = (0, account_1.selectToken)(getState());
+        if (!token)
+            throw new Error(types_2.MISSING_CUSTOMER);
+        yield api.deleteCustomerLevelUp(token, requestData.levelupConnectId);
+        dispatch((0, notifications_1.showNotification)('LevelUp disconnected!'));
+        if (requestData.callback)
+            requestData.callback();
+        return [];
+    }
+    catch (err) {
+        const error = err;
+        return (0, account_1.checkAuth)(error, dispatch, () => rejectWithValue(error));
+    }
+}));
+exports.addCustomerLevelUp = (0, toolkit_1.createAsyncThunk)(CustomerLevelUpActionType.AddCustomerLevelUp, (requestData, { dispatch, getState, rejectWithValue }) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const api = getState().config.api;
+        const token = (0, account_1.selectToken)(getState());
+        if (!token)
+            throw new Error(types_2.MISSING_CUSTOMER);
+        const response = yield api.postCustomerLevelUp(token, requestData.data);
+        dispatch((0, notifications_1.showNotification)('LevelUp connected!'));
+        if (requestData.callback)
+            requestData.callback();
+        return [response];
+    }
+    catch (err) {
+        const error = err;
+        return (0, account_1.checkAuth)(error, dispatch, () => rejectWithValue(error));
+    }
+}));
+const customerLevelUpSlice = (0, toolkit_1.createSlice)({
+    name: types_1.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(exports.fetchCustomerLevelUp.fulfilled, (state, action) => {
+            state.entities = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(exports.fetchCustomerLevelUp.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(exports.fetchCustomerLevelUp.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        })
+            .addCase(exports.removeCustomerLevelUp.fulfilled, (state, action) => {
+            state.entities = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(exports.removeCustomerLevelUp.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(exports.removeCustomerLevelUp.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        })
+            .addCase(exports.addCustomerLevelUp.fulfilled, (state, action) => {
+            state.entities = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(exports.addCustomerLevelUp.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(exports.addCustomerLevelUp.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        });
+    }
+});
+_a = customerLevelUpSlice.actions, exports.resetCustomerLevelUp = _a.resetCustomerLevelUp, exports.setCustomerLevelUp = _a.setCustomerLevelUp;
+const selectCustomerLevelUp = (state) => state.customer.levelup;
+exports.selectCustomerLevelUp = selectCustomerLevelUp;
+exports.customerLevelUpReducer = customerLevelUpSlice.reducer;

package/dist/cjs/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/cjs/slices/customer/loyalty.js

@@ -0,0 +1,87 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.customerLoyaltyReducer = exports.selectCustomerPoints = exports.selectCustomerPointsProgram = exports.selectCustomerLoyaltyProgram = exports.selectCustomerLoyalty = exports.setCustomerLoyalty = exports.resetCustomerLoyaltyError = exports.resetCustomerLoyalty = exports.fetchCustomerLoyalty = exports.CustomerLoyaltyActionType = void 0;
+const tslib_1 = require("tslib");
+const toolkit_1 = require("@reduxjs/toolkit");
+const types_1 = require("../types");
+const types_2 = require("@open-tender/types");
+const account_1 = require("./account");
+const initialState = {
+    entities: [],
+    error: null,
+    loading: 'idle',
+    lookup: {}
+};
+var CustomerLoyaltyActionType;
+(function (CustomerLoyaltyActionType) {
+    CustomerLoyaltyActionType["FetchCustomerLoyalty"] = "customer/fetchCustomerLoyalty";
+})(CustomerLoyaltyActionType = exports.CustomerLoyaltyActionType || (exports.CustomerLoyaltyActionType = {}));
+exports.fetchCustomerLoyalty = (0, toolkit_1.createAsyncThunk)(CustomerLoyaltyActionType.FetchCustomerLoyalty, (_, { dispatch, getState, rejectWithValue }) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const api = getState().config.api;
+        const token = (0, account_1.selectToken)(getState());
+        if (!token)
+            throw new Error(types_2.MISSING_CUSTOMER);
+        const loyalty = yield api.getCustomerLoyalty(token);
+        return loyalty;
+    }
+    catch (err) {
+        const error = err;
+        return (0, account_1.checkAuth)(error, dispatch, () => rejectWithValue(error));
+    }
+}));
+const customerLoyaltySlice = (0, toolkit_1.createSlice)({
+    name: types_1.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(exports.fetchCustomerLoyalty.fulfilled, (state, action) => {
+            state.entities = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(exports.fetchCustomerLoyalty.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(exports.fetchCustomerLoyalty.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        });
+    }
+});
+_a = customerLoyaltySlice.actions, exports.resetCustomerLoyalty = _a.resetCustomerLoyalty, exports.resetCustomerLoyaltyError = _a.resetCustomerLoyaltyError, exports.setCustomerLoyalty = _a.setCustomerLoyalty;
+const selectCustomerLoyalty = (state) => state.customer.loyalty;
+exports.selectCustomerLoyalty = selectCustomerLoyalty;
+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 };
+};
+exports.selectCustomerLoyaltyProgram = selectCustomerLoyaltyProgram;
+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;
+};
+exports.selectCustomerPointsProgram = selectCustomerPointsProgram;
+const selectCustomerPoints = (orderType) => (state) => {
+    const program = (0, exports.selectCustomerPointsProgram)(orderType)(state);
+    return program ? program.points : null;
+};
+exports.selectCustomerPoints = selectCustomerPoints;
+exports.customerLoyaltyReducer = customerLoyaltySlice.reducer;

package/dist/cjs/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>;

package/dist/cjs/slices/customer/order.js

@@ -0,0 +1,84 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.customerOrderReducer = exports.selectCustomerOrder = exports.setCustomerOrder = exports.resetCustomerOrderError = exports.resetCustomerOrder = exports.updateCustomerOrderRating = exports.fetchCustomerOrder = exports.CustomerOrderActionType = void 0;
+const tslib_1 = require("tslib");
+const toolkit_1 = require("@reduxjs/toolkit");
+const types_1 = require("../types");
+const types_2 = require("@open-tender/types");
+const account_1 = require("./account");
+const notifications_1 = require("../notifications");
+const initialState = {
+    entity: {},
+    error: null,
+    loading: 'idle'
+};
+var CustomerOrderActionType;
+(function (CustomerOrderActionType) {
+    CustomerOrderActionType["FetchCustomerOrder"] = "customer/fetchCustomerOrder";
+    CustomerOrderActionType["UpdateCustomerFavorite"] = "customer/updateCustomerFavorite";
+})(CustomerOrderActionType = exports.CustomerOrderActionType || (exports.CustomerOrderActionType = {}));
+exports.fetchCustomerOrder = (0, toolkit_1.createAsyncThunk)(CustomerOrderActionType.FetchCustomerOrder, (orderId, { dispatch, getState, rejectWithValue }) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const api = getState().config.api;
+        const token = (0, account_1.selectToken)(getState());
+        if (!token)
+            throw new Error(types_2.MISSING_CUSTOMER);
+        const order = yield api.getCustomerOrder(token, orderId);
+        return order;
+    }
+    catch (err) {
+        const error = err;
+        return (0, account_1.checkAuth)(error, dispatch, () => rejectWithValue(error));
+    }
+}));
+exports.updateCustomerOrderRating = (0, toolkit_1.createAsyncThunk)(CustomerOrderActionType.FetchCustomerOrder, (requestData, { dispatch, getState, rejectWithValue }) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const api = getState().config.api;
+        const token = (0, account_1.selectToken)(getState());
+        if (!token)
+            throw new Error(types_2.MISSING_CUSTOMER);
+        const response = yield api.putCustomerOrderRating(token, requestData.orderId, requestData.data);
+        dispatch((0, exports.fetchCustomerOrder)(requestData.orderId));
+        dispatch((0, notifications_1.showNotification)('Rating updated!'));
+        return response;
+    }
+    catch (err) {
+        const error = err;
+        return (0, account_1.checkAuth)(error, dispatch, () => rejectWithValue(error));
+    }
+}));
+const customerOrderSlice = (0, toolkit_1.createSlice)({
+    name: types_1.ReducerType.Order,
+    initialState,
+    reducers: {
+        resetCustomerOrder: () => initialState,
+        resetCustomerOrderError: state => {
+            state.error = null;
+            state.loading = 'idle';
+        },
+        setCustomerOrder: (state, action) => {
+            state.entity = action.payload;
+            state.error = null;
+        }
+    },
+    extraReducers: builder => {
+        builder
+            .addCase(exports.fetchCustomerOrder.fulfilled, (state, action) => {
+            state.entity = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(exports.fetchCustomerOrder.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(exports.fetchCustomerOrder.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        });
+    }
+});
+_a = customerOrderSlice.actions, exports.resetCustomerOrder = _a.resetCustomerOrder, exports.resetCustomerOrderError = _a.resetCustomerOrderError, exports.setCustomerOrder = _a.setCustomerOrder;
+const selectCustomerOrder = (state) => state.customer.order;
+exports.selectCustomerOrder = selectCustomerOrder;
+exports.customerOrderReducer = customerOrderSlice.reducer;

package/dist/cjs/slices/customer/orders.d.ts

@@ -0,0 +1,20 @@
+import { AppState } from '../../app';
+import { Orders, RequestError, RequestStatus } from '@open-tender/types';
+export interface CustomerOrdersState {
+    entities: Orders;
+    error: RequestError;
+    loading: RequestStatus;
+    lookup: {
+        [key: number]: number;
+    };
+}
+export declare enum CustomerOrdersActionType {
+    FetchCustomerOrders = "customer/fetchCustomerOrders"
+}
+export declare const fetchCustomerOrders: import("@reduxjs/toolkit").AsyncThunk<Orders, number, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const resetCustomerOrders: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>, resetCustomerOrdersError: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>, setCustomerOrders: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, string>;
+export declare const selectCustomerOrders: (state: AppState) => CustomerOrdersState;
+export declare const customerOrdersReducer: import("redux").Reducer<CustomerOrdersState, import("redux").AnyAction>;

package/dist/cjs/slices/customer/orders.js

@@ -0,0 +1,67 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.customerOrdersReducer = exports.selectCustomerOrders = exports.setCustomerOrders = exports.resetCustomerOrdersError = exports.resetCustomerOrders = exports.fetchCustomerOrders = exports.CustomerOrdersActionType = void 0;
+const tslib_1 = require("tslib");
+const toolkit_1 = require("@reduxjs/toolkit");
+const types_1 = require("../types");
+const types_2 = require("@open-tender/types");
+const account_1 = require("./account");
+const initialState = {
+    entities: [],
+    error: null,
+    loading: 'idle',
+    lookup: {}
+};
+var CustomerOrdersActionType;
+(function (CustomerOrdersActionType) {
+    CustomerOrdersActionType["FetchCustomerOrders"] = "customer/fetchCustomerOrders";
+})(CustomerOrdersActionType = exports.CustomerOrdersActionType || (exports.CustomerOrdersActionType = {}));
+exports.fetchCustomerOrders = (0, toolkit_1.createAsyncThunk)(CustomerOrdersActionType.FetchCustomerOrders, (limit, { dispatch, getState, rejectWithValue }) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const api = getState().config.api;
+        const token = (0, account_1.selectToken)(getState());
+        if (!token)
+            throw new Error(types_2.MISSING_CUSTOMER);
+        const { data: orders } = yield api.getCustomerOrders(token, limit);
+        return orders;
+    }
+    catch (err) {
+        const error = err;
+        return (0, account_1.checkAuth)(error, dispatch, () => rejectWithValue(error));
+    }
+}));
+const customerOrdersSlice = (0, toolkit_1.createSlice)({
+    name: types_1.ReducerType.Orders,
+    initialState,
+    reducers: {
+        resetCustomerOrders: () => initialState,
+        resetCustomerOrdersError: state => {
+            state.error = null;
+            state.loading = 'idle';
+        },
+        setCustomerOrders: (state, action) => {
+            state.entities = action.payload;
+            state.error = null;
+        }
+    },
+    extraReducers: builder => {
+        builder
+            .addCase(exports.fetchCustomerOrders.fulfilled, (state, action) => {
+            state.entities = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(exports.fetchCustomerOrders.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(exports.fetchCustomerOrders.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        });
+    }
+});
+_a = customerOrdersSlice.actions, exports.resetCustomerOrders = _a.resetCustomerOrders, exports.resetCustomerOrdersError = _a.resetCustomerOrdersError, exports.setCustomerOrders = _a.setCustomerOrders;
+const selectCustomerOrders = (state) => state.customer.orders;
+exports.selectCustomerOrders = selectCustomerOrders;
+exports.customerOrdersReducer = customerOrdersSlice.reducer;

package/dist/cjs/slices/customer/qrCode.d.ts

@@ -0,0 +1,17 @@
+import { AppState } from '../../app';
+import { RequestError, RequestStatus } from '@open-tender/types';
+export interface CustomerQRCodeState {
+    qrcode: string | null;
+    error: RequestError;
+    loading: RequestStatus;
+}
+export declare enum CustomerQRCodeActionType {
+    FetchCustomerQRCode = "customer/fetchCustomerQRCode"
+}
+export declare const fetchCustomerQRCode: import("@reduxjs/toolkit").AsyncThunk<string, void, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const resetCustomerQRCode: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
+export declare const selectCustomerQRCode: (state: AppState) => CustomerQRCodeState;
+export declare const customerQRCodeReducer: import("redux").Reducer<CustomerQRCodeState, import("redux").AnyAction>;

package/dist/cjs/slices/customer/qrCode.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.customerQRCodeReducer = exports.selectCustomerQRCode = exports.resetCustomerQRCode = exports.fetchCustomerQRCode = exports.CustomerQRCodeActionType = void 0;
+const tslib_1 = require("tslib");
+const toolkit_1 = require("@reduxjs/toolkit");
+const types_1 = require("../types");
+const types_2 = require("@open-tender/types");
+const account_1 = require("./account");
+const initialState = {
+    qrcode: null,
+    error: null,
+    loading: 'idle'
+};
+var CustomerQRCodeActionType;
+(function (CustomerQRCodeActionType) {
+    CustomerQRCodeActionType["FetchCustomerQRCode"] = "customer/fetchCustomerQRCode";
+})(CustomerQRCodeActionType = exports.CustomerQRCodeActionType || (exports.CustomerQRCodeActionType = {}));
+exports.fetchCustomerQRCode = (0, toolkit_1.createAsyncThunk)(CustomerQRCodeActionType.FetchCustomerQRCode, (_, { dispatch, getState, rejectWithValue }) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const api = getState().config.api;
+        const token = (0, account_1.selectToken)(getState());
+        if (!token)
+            throw new Error(types_2.MISSING_CUSTOMER);
+        const { qr_code_url } = yield api.getCustomerQRCode(token);
+        return qr_code_url;
+    }
+    catch (err) {
+        const error = err;
+        return (0, account_1.checkAuth)(error, dispatch, () => rejectWithValue(error));
+    }
+}));
+const customerQRCodeSlice = (0, toolkit_1.createSlice)({
+    name: types_1.ReducerType.QRCode,
+    initialState,
+    reducers: {
+        resetCustomerQRCode: () => initialState
+    },
+    extraReducers: builder => {
+        builder
+            .addCase(exports.fetchCustomerQRCode.fulfilled, (state, action) => {
+            state.qrcode = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(exports.fetchCustomerQRCode.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(exports.fetchCustomerQRCode.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        });
+    }
+});
+exports.resetCustomerQRCode = customerQRCodeSlice.actions.resetCustomerQRCode;
+const selectCustomerQRCode = (state) => state.customer.qrcode;
+exports.selectCustomerQRCode = selectCustomerQRCode;
+exports.customerQRCodeReducer = customerQRCodeSlice.reducer;

package/dist/cjs/slices/customer/rewards.d.ts

@@ -0,0 +1,20 @@
+import { AppState } from '../../app';
+import { Rewards, RequestError, RequestStatus } from '@open-tender/types';
+export interface CustomerRewardsState {
+    entities: Rewards;
+    error: RequestError;
+    loading: RequestStatus;
+    lookup: {
+        [key: number]: number;
+    };
+}
+export declare enum CustomerRewardsActionType {
+    FetchCustomerRewards = "customer/fetchCustomerRewards"
+}
+export declare const fetchCustomerRewards: import("@reduxjs/toolkit").AsyncThunk<Rewards, void, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const resetCustomerRewards: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>, resetCustomerRewardsError: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>, setCustomerRewards: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, string>;
+export declare const selectCustomerRewards: (state: AppState) => CustomerRewardsState;
+export declare const customerRewardsReducer: import("redux").Reducer<CustomerRewardsState, import("redux").AnyAction>;

package/dist/cjs/slices/customer/rewards.js

@@ -0,0 +1,67 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.customerRewardsReducer = exports.selectCustomerRewards = exports.setCustomerRewards = exports.resetCustomerRewardsError = exports.resetCustomerRewards = exports.fetchCustomerRewards = exports.CustomerRewardsActionType = void 0;
+const tslib_1 = require("tslib");
+const toolkit_1 = require("@reduxjs/toolkit");
+const types_1 = require("../types");
+const types_2 = require("@open-tender/types");
+const account_1 = require("./account");
+const initialState = {
+    entities: [],
+    error: null,
+    loading: 'idle',
+    lookup: {}
+};
+var CustomerRewardsActionType;
+(function (CustomerRewardsActionType) {
+    CustomerRewardsActionType["FetchCustomerRewards"] = "customer/fetchCustomerRewards";
+})(CustomerRewardsActionType = exports.CustomerRewardsActionType || (exports.CustomerRewardsActionType = {}));
+exports.fetchCustomerRewards = (0, toolkit_1.createAsyncThunk)(CustomerRewardsActionType.FetchCustomerRewards, (_, { dispatch, getState, rejectWithValue }) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const api = getState().config.api;
+        const token = (0, account_1.selectToken)(getState());
+        if (!token)
+            throw new Error(types_2.MISSING_CUSTOMER);
+        const rewards = yield api.getCustomerRewards(token);
+        return rewards;
+    }
+    catch (err) {
+        const error = err;
+        return (0, account_1.checkAuth)(error, dispatch, () => rejectWithValue(error));
+    }
+}));
+const customerRewardsSlice = (0, toolkit_1.createSlice)({
+    name: types_1.ReducerType.Rewards,
+    initialState,
+    reducers: {
+        resetCustomerRewards: () => initialState,
+        resetCustomerRewardsError: state => {
+            state.error = null;
+            state.loading = 'idle';
+        },
+        setCustomerRewards: (state, action) => {
+            state.entities = action.payload;
+            state.error = null;
+        }
+    },
+    extraReducers: builder => {
+        builder
+            .addCase(exports.fetchCustomerRewards.fulfilled, (state, action) => {
+            state.entities = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(exports.fetchCustomerRewards.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(exports.fetchCustomerRewards.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        });
+    }
+});
+_a = customerRewardsSlice.actions, exports.resetCustomerRewards = _a.resetCustomerRewards, exports.resetCustomerRewardsError = _a.resetCustomerRewardsError, exports.setCustomerRewards = _a.setCustomerRewards;
+const selectCustomerRewards = (state) => state.customer.rewards;
+exports.selectCustomerRewards = selectCustomerRewards;
+exports.customerRewardsReducer = customerRewardsSlice.reducer;

package/dist/cjs/slices/customer/thanx.d.ts

@@ -0,0 +1,17 @@
+import { AppState } from '../../app';
+import { Thanx, RequestError, RequestStatus } from '@open-tender/types';
+export interface CustomerThanxState {
+    thanx: Thanx | null;
+    error: RequestError;
+    loading: RequestStatus;
+}
+export declare enum CustomerThanxActionType {
+    FetchCustomerThanx = "customer/fetchCustomerThanx"
+}
+export declare const fetchCustomerThanx: import("@reduxjs/toolkit").AsyncThunk<Thanx, void, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const resetCustomerThanx: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
+export declare const selectCustomerThanx: (state: AppState) => CustomerThanxState;
+export declare const customerThanxReducer: import("redux").Reducer<CustomerThanxState, import("redux").AnyAction>;