@open-tender/cloud/dist/cjs/slices/customer/groupOrders.js

A library of hooks, reducers, utility functions, and types for use with Open Tender applications that utilize our cloud-based Order API.

"use strict";
var _a;
Object.defineProperty(exports, "__esModule", { value: true });
exports.customerGroupOrdersReducer = exports.selectCustomerGroupOrders = exports.setCustomerGroupOrders = exports.resetCustomerGroupOrdersError = exports.resetCustomerGroupOrders = exports.reopenGroupOrder = exports.removeCustomerGroupOrder = exports.closeGroupOrder = exports.updateCustomerGroupOrder = exports.makeCartData = exports.fetchCustomerGroupOrder = exports.fetchCustomerGroupOrders = exports.CustomerGroupOrdersActionType = 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 groupOrder_1 = require("../groupOrder");
const order_1 = require("../order");
const utils_1 = require("@open-tender/utils");
const notifications_1 = require("../notifications");
const initialState = {
    entities: [],
    lookup: {},
    loading: 'idle',
    error: null
};
var CustomerGroupOrdersActionType;
(function (CustomerGroupOrdersActionType) {
    CustomerGroupOrdersActionType["FetchCustomerGroupOrders"] = "customer/fetchCustomerGroupOrders";
    CustomerGroupOrdersActionType["FetchCustomerGroupOrder"] = "customer/fetchCustomerGroupOrder";
    CustomerGroupOrdersActionType["RemoveCustomerGroupOrder"] = "customer/removeCustomerGroupOrder";
    CustomerGroupOrdersActionType["ReopenGroupOrder"] = "customer/reopenGroupOrder";
    CustomerGroupOrdersActionType["UpdateCustomerGroupOrder"] = "customer/updateCustomerGroupOrder";
    CustomerGroupOrdersActionType["CloseCustomerGroupOrder"] = "customer/closeCustomerGroupOrder";
})(CustomerGroupOrdersActionType = exports.CustomerGroupOrdersActionType || (exports.CustomerGroupOrdersActionType = {}));
exports.fetchCustomerGroupOrders = (0, toolkit_1.createAsyncThunk)(CustomerGroupOrdersActionType.FetchCustomerGroupOrders, (_, { 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 orders = yield api.getCustomerGroupOrders(token);
        return orders;
    }
    catch (err) {
        const error = err;
        return (0, account_1.checkAuth)(error, dispatch, () => rejectWithValue(error));
    }
}));
exports.fetchCustomerGroupOrder = (0, toolkit_1.createAsyncThunk)(CustomerGroupOrdersActionType.FetchCustomerGroupOrder, (cartId, { 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.getCustomerGroupOrder(token, cartId);
        const payload = Object.assign(Object.assign({}, (0, groupOrder_1.makeCartPayload)(response)), { isCartOwner: true });
        return payload;
    }
    catch (err) {
        const error = err;
        return (0, account_1.checkAuth)(error, dispatch, () => rejectWithValue(error));
    }
}));
const makeCartData = (order, spendingLimit) => {
    const { address, revenueCenter, requestedAt, serviceType, cart } = order;
    if (!revenueCenter)
        return null;
    const orderData = {
        address,
        revenue_center_id: revenueCenter === null || revenueCenter === void 0 ? void 0 : revenueCenter.revenue_center_id,
        service_type: serviceType,
        requested_at: requestedAt,
        cart: cart ? (0, utils_1.makeSimpleCart)(cart) : []
    };
    return spendingLimit
        ? Object.assign(Object.assign({}, orderData), { spending_limit: spendingLimit }) : orderData;
};
exports.makeCartData = makeCartData;
exports.updateCustomerGroupOrder = (0, toolkit_1.createAsyncThunk)(CustomerGroupOrdersActionType.UpdateCustomerGroupOrder, ({ cartId, callback }, { 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 cartData = (0, exports.makeCartData)(getState().order);
        yield api.putCustomerGroupOrder(token, cartId, cartData);
        const response = yield api.getCustomerGroupOrder(token, cartId);
        const { requestedAt, revenueCenter } = getState().order;
        if (response.requested_at !== requestedAt) {
            dispatch((0, order_1.setRequestedAt)(response.requested_at));
            if (revenueCenter) {
                const tz = utils_1.timezoneMap[revenueCenter.timezone];
                const requestedAtText = (0, utils_1.makeRequestedAtStr)(response.requested_at, tz);
                dispatch((0, order_1.addMessage)(`Requested time updated to ${requestedAtText}`));
            }
        }
        const payload = Object.assign(Object.assign({}, (0, groupOrder_1.makeCartPayload)(response)), { isCartOwner: true });
        dispatch((0, groupOrder_1.adjustGroupOrder)(payload));
        if (callback)
            callback();
    }
    catch (err) {
        const error = err;
        return (0, account_1.checkAuth)(error, dispatch, () => rejectWithValue(error));
    }
}));
exports.closeGroupOrder = (0, toolkit_1.createAsyncThunk)(CustomerGroupOrdersActionType.CloseCustomerGroupOrder, (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.putCustomerGroupOrderStatus(token, requestData.cartId, {
            closed
        });
        return requestData.closed;
    }
    catch (err) {
        const error = err;
        return (0, account_1.checkAuth)(error, dispatch, () => rejectWithValue(error));
    }
}));
exports.removeCustomerGroupOrder = (0, toolkit_1.createAsyncThunk)(CustomerGroupOrdersActionType.RemoveCustomerGroupOrder, (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.deleteCustomerGroupOrder(token, requestData.cartId);
        dispatch((0, groupOrder_1.resetGroupOrder)());
        const orders = yield api.getCustomerGroupOrders(token);
        dispatch((0, notifications_1.showNotification)('Group order deleted!'));
        if (requestData.callback)
            requestData.callback();
        return orders;
    }
    catch (err) {
        dispatch((0, groupOrder_1.resetGroupOrder)());
        dispatch((0, notifications_1.showNotification)('Group order deleted!'));
        const error = err;
        return (0, account_1.checkAuth)(error, dispatch, () => rejectWithValue(error));
    }
}));
exports.reopenGroupOrder = (0, toolkit_1.createAsyncThunk)(CustomerGroupOrdersActionType.ReopenGroupOrder, (cart, { 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 alert = {
            type: 'working',
            args: { text: 'Building your order...' }
        };
        dispatch((0, order_1.setAlert)(alert));
        const { revenue_center_id, service_type, requested_at, cart_id } = cart;
        const revenueCenter = yield api.getLocation(revenue_center_id);
        dispatch((0, order_1.setRevenueCenter)(revenueCenter));
        const menuItems = yield api.getMenuItems(revenue_center_id, service_type);
        const data = { revenue_center_id, requested_at, service_type };
        const response = yield api.putCustomerGroupOrder(token, cart_id, data);
        dispatch((0, order_1.setRequestedAt)(response.requested_at));
        const customer = getState().customer.account.profile;
        const { customer_id } = customer || {};
        const items = response.cart.filter((i) => i.customer_id === customer_id);
        const { cart: customerCart } = (0, utils_1.rehydrateCart)(menuItems, items);
        dispatch((0, order_1.setCart)(customerCart));
        const payload = Object.assign(Object.assign({}, (0, groupOrder_1.makeCartPayload)(response)), { isCartOwner: true, cartOwner: customer });
        dispatch((0, groupOrder_1.adjustGroupOrder)(payload));
        dispatch((0, notifications_1.showNotification)('Group order reopened!'));
        dispatch((0, order_1.setAlert)({ type: 'groupOrder' }));
    }
    catch (err) {
        dispatch((0, order_1.resetAlert)());
        dispatch((0, order_1.addMessage)('Something went wrong. Please contact support.'));
        const error = err;
        return (0, account_1.checkAuth)(error, dispatch, () => rejectWithValue(error));
    }
}));
const customerGroupOrdersSlice = (0, toolkit_1.createSlice)({
    name: types_1.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(exports.fetchCustomerGroupOrders.fulfilled, (state, action) => {
            state.entities = action.payload;
            state.loading = 'idle';
            state.error = null;
        })
            .addCase(exports.fetchCustomerGroupOrders.pending, state => {
            state.loading = 'pending';
        })
            .addCase(exports.fetchCustomerGroupOrders.rejected, (state, action) => {
            state.error = action.payload;
            state.loading = 'idle';
        })
            .addCase(exports.fetchCustomerGroupOrder.fulfilled, (state, action) => {
            state.entities = [action.payload];
            state.loading = 'idle';
            state.error = null;
        })
            .addCase(exports.fetchCustomerGroupOrder.pending, state => {
            state.loading = 'pending';
        })
            .addCase(exports.fetchCustomerGroupOrder.rejected, (state, action) => {
            state.error = action.payload;
            state.loading = 'idle';
        })
            .addCase(exports.removeCustomerGroupOrder.fulfilled, (state, action) => {
            state.entities = action.payload;
            state.loading = 'idle';
            state.error = null;
        })
            .addCase(exports.removeCustomerGroupOrder.pending, state => {
            state.loading = 'pending';
        })
            .addCase(exports.removeCustomerGroupOrder.rejected, (state, action) => {
            state.error = action.payload;
            state.loading = 'idle';
        })
            .addCase(exports.reopenGroupOrder.fulfilled, state => {
            state.error = null;
            state.loading = 'idle';
        })
            .addCase(exports.reopenGroupOrder.pending, state => {
            state.loading = 'pending';
        })
            .addCase(exports.reopenGroupOrder.rejected, (state, action) => {
            state.error = action.payload;
            state.loading = 'idle';
        })
            .addCase(exports.updateCustomerGroupOrder.fulfilled, state => {
            state.error = null;
            state.loading = 'idle';
        })
            .addCase(exports.updateCustomerGroupOrder.pending, state => {
            state.loading = 'pending';
        })
            .addCase(exports.updateCustomerGroupOrder.rejected, (state, action) => {
            state.error = action.payload;
            state.loading = 'idle';
        })
            .addCase(exports.closeGroupOrder.fulfilled, (state, action) => {
            return Object.assign(Object.assign({}, state), { closed: action.payload, loading: 'idle', error: null });
        })
            .addCase(exports.closeGroupOrder.pending, state => {
            state.loading = 'pending';
        })
            .addCase(exports.closeGroupOrder.rejected, (state, action) => {
            state.error = action.payload;
            state.loading = 'idle';
        });
    }
});
_a = customerGroupOrdersSlice.actions, exports.resetCustomerGroupOrders = _a.resetCustomerGroupOrders, exports.resetCustomerGroupOrdersError = _a.resetCustomerGroupOrdersError, exports.setCustomerGroupOrders = _a.setCustomerGroupOrders;
const selectCustomerGroupOrders = (state) => state.customer.groupOrders;
exports.selectCustomerGroupOrders = selectCustomerGroupOrders;
exports.customerGroupOrdersReducer = customerGroupOrdersSlice.reducer;