@open-tender/cloud 0.0.1

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

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.customerThanxReducer = exports.selectCustomerThanx = exports.resetCustomerThanx = exports.fetchCustomerThanx = exports.CustomerThanxActionType = 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 = {
+    thanx: null,
+    error: null,
+    loading: 'idle'
+};
+var CustomerThanxActionType;
+(function (CustomerThanxActionType) {
+    CustomerThanxActionType["FetchCustomerThanx"] = "customer/fetchCustomerThanx";
+})(CustomerThanxActionType = exports.CustomerThanxActionType || (exports.CustomerThanxActionType = {}));
+exports.fetchCustomerThanx = (0, toolkit_1.createAsyncThunk)(CustomerThanxActionType.FetchCustomerThanx, (_, { 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 resp = yield api.getCustomerThanx(token);
+        return resp;
+    }
+    catch (err) {
+        const error = err;
+        return (0, account_1.checkAuth)(error, dispatch, () => rejectWithValue(error));
+    }
+}));
+const customerThanxSlice = (0, toolkit_1.createSlice)({
+    name: types_1.ReducerType.Thanx,
+    initialState,
+    reducers: {
+        resetCustomerThanx: () => initialState
+    },
+    extraReducers: builder => {
+        builder
+            .addCase(exports.fetchCustomerThanx.fulfilled, (state, action) => {
+            state.thanx = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(exports.fetchCustomerThanx.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(exports.fetchCustomerThanx.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        });
+    }
+});
+exports.resetCustomerThanx = customerThanxSlice.actions.resetCustomerThanx;
+const selectCustomerThanx = (state) => state.customer.thanx;
+exports.selectCustomerThanx = selectCustomerThanx;
+exports.customerThanxReducer = customerThanxSlice.reducer;

package/dist/cjs/slices/deals.d.ts

@@ -0,0 +1,19 @@
+import { AppState } from '../app';
+import { Deals, Deal, RequestError, RequestStatus } from '@open-tender/types';
+export interface DealState {
+    entities: Deals;
+    error: RequestError;
+    loading: RequestStatus;
+    selected: Deal | null;
+}
+export declare enum DealActionType {
+    FetchDeals = "deals/fetchDeals"
+}
+export declare const fetchDeals: import("@reduxjs/toolkit").AsyncThunk<Deals, void, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const resetDeals: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>, setSelectedDeals: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, string>;
+export declare const selectDeals: (state: AppState) => DealState;
+export declare const selectEligibleDeals: (state: AppState) => Deals;
+export declare const dealsReducer: import("redux").Reducer<DealState, import("redux").AnyAction>;

package/dist/cjs/slices/deals.js

@@ -0,0 +1,97 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dealsReducer = exports.selectEligibleDeals = exports.selectDeals = exports.setSelectedDeals = exports.resetDeals = exports.fetchDeals = exports.DealActionType = void 0;
+const tslib_1 = require("tslib");
+const toolkit_1 = require("@reduxjs/toolkit");
+const types_1 = require("./types");
+const utils_1 = require("@open-tender/utils");
+const initialState = {
+    entities: [],
+    selected: null,
+    error: null,
+    loading: 'idle'
+};
+var DealActionType;
+(function (DealActionType) {
+    DealActionType["FetchDeals"] = "deals/fetchDeals";
+})(DealActionType = exports.DealActionType || (exports.DealActionType = {}));
+exports.fetchDeals = (0, toolkit_1.createAsyncThunk)(DealActionType.FetchDeals, (_, { getState, rejectWithValue }) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    const { api } = getState().config;
+    if (!api)
+        return;
+    try {
+        const { profile } = getState().customer.account;
+        const { customer_id = null } = profile || {};
+        const deals = yield api.getDeals(customer_id);
+        return deals;
+    }
+    catch (err) {
+        return rejectWithValue(err);
+    }
+}));
+const dealsSlice = (0, toolkit_1.createSlice)({
+    name: types_1.ReducerType.Deals,
+    initialState,
+    reducers: {
+        resetDeals: () => initialState,
+        setSelectedDeals: (state, action) => {
+            state.selected = action.payload;
+        }
+    },
+    extraReducers: builder => {
+        builder
+            .addCase(exports.fetchDeals.fulfilled, (state, action) => {
+            state.entities = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(exports.fetchDeals.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(exports.fetchDeals.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        });
+    }
+});
+_a = dealsSlice.actions, exports.resetDeals = _a.resetDeals, exports.setSelectedDeals = _a.setSelectedDeals;
+const selectDeals = (state) => state.deals;
+exports.selectDeals = selectDeals;
+const selectEligibleDeals = (state) => {
+    const { brand } = state.config || {};
+    if (!brand || !brand.has_deals)
+        return [];
+    let { entities: deals } = state.deals;
+    const { orderType, serviceType, revenueCenter } = state.order;
+    if (orderType) {
+        deals = deals.filter(i => !i.order_type || i.order_type === orderType);
+    }
+    if (serviceType) {
+        deals = deals.filter(i => !i.service_type || i.service_type === serviceType);
+    }
+    if (revenueCenter) {
+        const { revenue_center_id } = revenueCenter;
+        deals = deals.filter(i => {
+            var _a;
+            return !((_a = i.revenue_centers) === null || _a === void 0 ? void 0 : _a.length) ||
+                i.revenue_centers
+                    .map(r => r.revenue_center_id)
+                    .includes(revenue_center_id);
+        });
+    }
+    const minutes = (0, utils_1.getMinutesfromDate)(new Date());
+    deals = deals.filter(i => {
+        if (!i.dayparts.length)
+            return true;
+        const validDayparts = i.dayparts.filter(d => {
+            const start = (0, utils_1.time24ToMinutes)(d.start_time);
+            const end = (0, utils_1.time24ToMinutes)(d.end_time);
+            return start <= minutes && minutes <= end;
+        });
+        return validDayparts.length > 0;
+    });
+    return deals;
+};
+exports.selectEligibleDeals = selectEligibleDeals;
+exports.dealsReducer = dealsSlice.reducer;

package/dist/cjs/slices/donations.d.ts

@@ -0,0 +1,26 @@
+import { AppState } from '../app';
+import { Donation, RequestError, RequestStatus, PurchaseDonationRequest } from '@open-tender/types';
+export interface DonationState {
+    donation: Donation | null;
+    error: RequestError | Record<string, any>;
+    loading: RequestStatus;
+    success: boolean;
+}
+export declare enum DonationActionType {
+    PurchaseDonation = "donations/purchaseDonation"
+}
+export declare const purchaseDonation: import("@reduxjs/toolkit").AsyncThunk<Donation, {
+    data: PurchaseDonationRequest;
+    callback?: (() => void) | undefined;
+}, {
+    state: AppState;
+    rejectValue: RequestError | Record<string, any>;
+}>;
+export declare const resetDonation: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
+export declare const selectDonation: (state: AppState) => {
+    success: boolean;
+    loading: RequestStatus;
+    error: RequestError | Record<string, any>;
+    donation: Donation | null;
+};
+export declare const donationsReducer: import("redux").Reducer<DonationState, import("redux").AnyAction>;

package/dist/cjs/slices/donations.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.donationsReducer = exports.selectDonation = exports.resetDonation = exports.purchaseDonation = exports.DonationActionType = void 0;
+const tslib_1 = require("tslib");
+const toolkit_1 = require("@reduxjs/toolkit");
+const types_1 = require("./types");
+const utils_1 = require("@open-tender/utils");
+const initialState = {
+    donation: null,
+    success: false,
+    error: null,
+    loading: 'idle'
+};
+var DonationActionType;
+(function (DonationActionType) {
+    DonationActionType["PurchaseDonation"] = "donations/purchaseDonation";
+})(DonationActionType = exports.DonationActionType || (exports.DonationActionType = {}));
+exports.purchaseDonation = (0, toolkit_1.createAsyncThunk)(DonationActionType.PurchaseDonation, (requestData, { getState, rejectWithValue }) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    const { api } = getState().config;
+    if (!api)
+        return;
+    try {
+        const donation = yield api.postPurchaseDonation(requestData.data);
+        if (requestData.callback)
+            requestData.callback();
+        return donation;
+    }
+    catch (err) {
+        const errors = (0, utils_1.makeFormErrors)(err);
+        return rejectWithValue(errors);
+    }
+}));
+const donationsSlice = (0, toolkit_1.createSlice)({
+    name: types_1.ReducerType.Donations,
+    initialState,
+    reducers: {
+        resetDonation: () => initialState
+    },
+    extraReducers: builder => {
+        builder
+            .addCase(exports.purchaseDonation.fulfilled, (state, action) => {
+            state.donation = action.payload;
+            state.success = true;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(exports.purchaseDonation.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(exports.purchaseDonation.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        });
+    }
+});
+exports.resetDonation = donationsSlice.actions.resetDonation;
+const selectDonation = (state) => {
+    const { success, loading, error, donation } = state.donations;
+    return { success, loading, error, donation };
+};
+exports.selectDonation = selectDonation;
+exports.donationsReducer = donationsSlice.reducer;

package/dist/cjs/slices/giftCards.d.ts

@@ -0,0 +1,26 @@
+import { AppState } from '../app';
+import { CustomerGiftCard, CustomerGiftCards, RequestError, RequestStatus } from '@open-tender/types';
+export interface GiftCardsState {
+    loading: RequestStatus;
+    error: RequestError;
+    success: boolean;
+    giftCards: CustomerGiftCards;
+}
+export declare enum GiftCardsActionType {
+    PurchaseGiftCards = "giftCards/purchaseGiftCards"
+}
+export declare const purchaseGiftCards: import("@reduxjs/toolkit").AsyncThunk<CustomerGiftCards, {
+    data: Partial<CustomerGiftCard>;
+    callback?: (() => void) | undefined;
+}, {
+    state: AppState;
+    rejectValue: any;
+}>;
+export declare const resetGiftCards: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
+export declare const selectGiftCards: (state: AppState) => {
+    success: boolean;
+    loading: RequestStatus;
+    error: RequestError;
+    giftCards: CustomerGiftCards;
+};
+export declare const giftCardsReducer: import("redux").Reducer<GiftCardsState, import("redux").AnyAction>;

package/dist/cjs/slices/giftCards.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.giftCardsReducer = exports.selectGiftCards = exports.resetGiftCards = exports.purchaseGiftCards = exports.GiftCardsActionType = void 0;
+const tslib_1 = require("tslib");
+const toolkit_1 = require("@reduxjs/toolkit");
+const types_1 = require("./types");
+const utils_1 = require("@open-tender/utils");
+const initialState = {
+    loading: 'idle',
+    error: null,
+    success: false,
+    giftCards: []
+};
+var GiftCardsActionType;
+(function (GiftCardsActionType) {
+    GiftCardsActionType["PurchaseGiftCards"] = "giftCards/purchaseGiftCards";
+})(GiftCardsActionType = exports.GiftCardsActionType || (exports.GiftCardsActionType = {}));
+exports.purchaseGiftCards = (0, toolkit_1.createAsyncThunk)(GiftCardsActionType.PurchaseGiftCards, (requestData, { getState, rejectWithValue }) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    const { api } = getState().config;
+    if (!api)
+        return;
+    try {
+        const giftCards = yield api.postPurchaseGiftCards(requestData.data);
+        if (requestData.callback)
+            requestData.callback();
+        return giftCards;
+    }
+    catch (err) {
+        const errors = (0, utils_1.makeFormErrors)(err);
+        return rejectWithValue(errors);
+    }
+}));
+const giftCardsSlice = (0, toolkit_1.createSlice)({
+    name: types_1.ReducerType.GiftCards,
+    initialState,
+    reducers: {
+        resetGiftCards: () => initialState
+    },
+    extraReducers: builder => {
+        builder
+            .addCase(exports.purchaseGiftCards.fulfilled, (state, action) => {
+            state.success = true;
+            state.giftCards = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(exports.purchaseGiftCards.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(exports.purchaseGiftCards.rejected, (state, action) => {
+            state.loading = 'idle';
+            state.success = false;
+            state.error = action.payload;
+        });
+    }
+});
+exports.resetGiftCards = giftCardsSlice.actions.resetGiftCards;
+const selectGiftCards = (state) => {
+    const { success, loading, error, giftCards } = state.giftCards;
+    return { success, loading, error, giftCards };
+};
+exports.selectGiftCards = selectGiftCards;
+exports.giftCardsReducer = giftCardsSlice.reducer;

package/dist/cjs/slices/groupOrder.d.ts

@@ -0,0 +1,80 @@
+import { AppState } from '../app';
+import { CartOwner, GroupOrder, ISOString, OrderItem, RequestError, RequestStatus, ServiceType } from '@open-tender/types';
+export interface GroupOrderState {
+    cart: Array<OrderItem>;
+    cartGuest: any;
+    cartGuests: any;
+    cartId: number | null;
+    cartOwner: CartOwner | null;
+    closed: boolean;
+    cutoffAt: string | null;
+    error: RequestError;
+    guestCount: number | null;
+    guestLimit: number | null;
+    isCartOwner: boolean;
+    loading: RequestStatus;
+    requestedAt: ISOString | null;
+    revenueCenterId: number | null;
+    serviceType: ServiceType | null;
+    spendingLimit: string | null;
+    token: string | null;
+}
+export declare enum GroupOrderActionType {
+    JoinGroupOrder = "groupOrder/joinGroupOrder",
+    FetchGroupOrder = "groupOrder/fetchGroupOrder",
+    UpdateGroupOrder = "groupOrder/updateGroupOrder",
+    ReloadGuestOrder = "groupOrder/reloadGuestOrder"
+}
+export declare const makeCartPayload: (response: GroupOrder, cartGuestId?: number) => {
+    cartId: number;
+    token: string;
+    revenueCenterId: number;
+    serviceType: ServiceType;
+    requestedAt: `${number}${number}${number}${number}-${number}${number}-${number}${number}T${number}${number}:${number}${number}:${number}${number}Z`;
+    cutoffAt: string;
+    guestLimit: number;
+    guestCount: number;
+    spendingLimit: string;
+    closed: boolean;
+    cartOwner: CartOwner | null;
+    cart: OrderItem[];
+    cartGuests: any;
+};
+export declare const joinGroupOrder: import("@reduxjs/toolkit").AsyncThunk<any, {
+    cart_id: number;
+    first_name: string;
+    last_name: string;
+}, {
+    state: AppState;
+    rejectValue: any;
+}>;
+export declare const fetchGroupOrder: import("@reduxjs/toolkit").AsyncThunk<void | Partial<GroupOrderState>, number, {
+    state: AppState;
+    rejectValue: any;
+}>;
+export declare const updateGroupOrder: import("@reduxjs/toolkit").AsyncThunk<void | Partial<GroupOrderState>, void, {
+    state: AppState;
+    rejectValue: any;
+}>;
+export declare const reloadGuestOrder: import("@reduxjs/toolkit").AsyncThunk<void, void, {
+    state: AppState;
+    rejectValue: any;
+}>;
+export declare const resetGroupOrder: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
+export declare const selectGroupOrder: (state: AppState) => GroupOrderState;
+export declare const selectGroupOrderToken: (state: AppState) => string | null;
+export declare const selectSpendingLimit: (state: AppState) => number | null;
+export declare const selectGroupOrderClosed: (state: AppState) => any;
+export declare const selectGroupOrderTests: (state: AppState) => {
+    closed: boolean;
+    pastCutoff: boolean;
+    atCapacity: boolean;
+};
+export declare const selectGroupOrderPrepTimes: (state: AppState) => {
+    prepTime?: undefined;
+    leadTime?: undefined;
+} | {
+    prepTime: number;
+    leadTime: number | undefined;
+};
+export declare const groupOrderReducer: import("redux").Reducer<GroupOrderState, import("redux").AnyAction>;

package/dist/cjs/slices/groupOrder.js

@@ -0,0 +1,226 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.groupOrderReducer = exports.selectGroupOrderPrepTimes = exports.selectGroupOrderTests = exports.selectGroupOrderClosed = exports.selectSpendingLimit = exports.selectGroupOrderToken = exports.selectGroupOrder = exports.resetGroupOrder = exports.reloadGuestOrder = exports.updateGroupOrder = exports.fetchGroupOrder = exports.joinGroupOrder = exports.makeCartPayload = exports.GroupOrderActionType = void 0;
+const tslib_1 = require("tslib");
+const toolkit_1 = require("@reduxjs/toolkit");
+const types_1 = require("./types");
+const order_1 = require("./order");
+const utils_1 = require("@open-tender/utils");
+const initialState = {
+    cartId: null,
+    token: null,
+    revenueCenterId: null,
+    serviceType: null,
+    requestedAt: null,
+    cutoffAt: null,
+    guestLimit: null,
+    guestCount: null,
+    spendingLimit: null,
+    closed: false,
+    isCartOwner: false,
+    cartOwner: null,
+    cartGuest: null,
+    cartGuests: [],
+    cart: [],
+    error: null,
+    loading: 'idle'
+};
+var GroupOrderActionType;
+(function (GroupOrderActionType) {
+    GroupOrderActionType["JoinGroupOrder"] = "groupOrder/joinGroupOrder";
+    GroupOrderActionType["FetchGroupOrder"] = "groupOrder/fetchGroupOrder";
+    GroupOrderActionType["UpdateGroupOrder"] = "groupOrder/updateGroupOrder";
+    GroupOrderActionType["ReloadGuestOrder"] = "groupOrder/reloadGuestOrder";
+})(GroupOrderActionType = exports.GroupOrderActionType || (exports.GroupOrderActionType = {}));
+const makeCartPayload = (response, cartGuestId) => {
+    const { customer = null, closed, cart_id: cartId, token, cart, revenue_center_id: revenueCenterId, service_type: serviceType, requested_at: requestedAt, cutoff_at: cutoffAt, spending_limit: spendingLimit, guest_limit: guestLimit, guest_count: guestCount, cart_guests: cartGuests } = response;
+    const filteredCart = cartGuestId
+        ? cart.filter(i => i.cart_guest_id === cartGuestId)
+        : cart;
+    return {
+        cartId,
+        token,
+        revenueCenterId,
+        serviceType,
+        requestedAt,
+        cutoffAt,
+        guestLimit,
+        guestCount,
+        spendingLimit,
+        closed,
+        cartOwner: customer,
+        cart: filteredCart,
+        cartGuests: cartGuests || []
+    };
+};
+exports.makeCartPayload = makeCartPayload;
+exports.joinGroupOrder = (0, toolkit_1.createAsyncThunk)(GroupOrderActionType.JoinGroupOrder, (requestData, { dispatch, getState, rejectWithValue }) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    const { api } = getState().config;
+    if (!api)
+        return null;
+    try {
+        const data = {
+            cart_id: requestData.cart_id,
+            first_name: requestData.first_name,
+            last_name: requestData.last_name
+        };
+        const response = yield api.postCartGuest(data);
+        const { cart_guest_id: cartGuestId, first_name: firstName, last_name: lastName } = response;
+        const { revenueCenter } = getState().order;
+        dispatch((0, order_1.resetOrder)());
+        const { serviceType, requestedAt } = getState().groupOrder;
+        dispatch((0, order_1.setMenuVars)({ revenueCenter, serviceType, requestedAt }));
+        dispatch((0, order_1.setCart)([]));
+        const payload = { cartGuestId, firstName, lastName };
+        return payload;
+    }
+    catch (err) {
+        return rejectWithValue(err);
+    }
+}));
+exports.fetchGroupOrder = (0, toolkit_1.createAsyncThunk)(GroupOrderActionType.FetchGroupOrder, (id, { getState, rejectWithValue }) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    const { api } = getState().config;
+    if (!api)
+        return;
+    try {
+        const response = yield api.getCart(id);
+        const { cartGuest } = getState().groupOrder;
+        const cartGuestId = cartGuest ? cartGuest.cartGuestId : null;
+        const payload = (0, exports.makeCartPayload)(response, cartGuestId);
+        return payload;
+    }
+    catch (err) {
+        return rejectWithValue(err);
+    }
+}));
+exports.updateGroupOrder = (0, toolkit_1.createAsyncThunk)(GroupOrderActionType.UpdateGroupOrder, (_, { dispatch, getState, rejectWithValue }) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    const { api } = getState().config;
+    if (!api)
+        return;
+    const { cartId, cartGuest } = getState().groupOrder;
+    try {
+        const data = {
+            cart: (0, utils_1.makeSimpleCart)((_a = getState().order.cart) !== null && _a !== void 0 ? _a : []),
+            cart_guest_id: cartGuest.cartGuestId
+        };
+        const response = yield api.putCart(cartId, data);
+        const payload = (0, exports.makeCartPayload)(response, cartGuest.cartGuestId);
+        return payload;
+    }
+    catch (err) {
+        yield dispatch((0, exports.fetchGroupOrder)(cartId));
+        return rejectWithValue(err);
+    }
+}));
+exports.reloadGuestOrder = (0, toolkit_1.createAsyncThunk)(GroupOrderActionType.ReloadGuestOrder, (_, { dispatch, getState, rejectWithValue }) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    const { api } = getState().config;
+    if (!api)
+        return;
+    try {
+        const { revenueCenterId, serviceType } = getState().groupOrder;
+        const { cart: items } = getState().groupOrder;
+        const menuItems = yield api.getMenuItems(revenueCenterId, serviceType);
+        const { cart } = (0, utils_1.rehydrateCart)(menuItems, items);
+        dispatch((0, order_1.setCart)(cart));
+        return;
+    }
+    catch (err) {
+        return rejectWithValue(err);
+    }
+}));
+const groupOrderSlice = (0, toolkit_1.createSlice)({
+    name: types_1.ReducerType.GroupOrder,
+    initialState,
+    reducers: {
+        resetGroupOrder: () => initialState,
+        deleteGroupOrder: () => initialState
+    },
+    extraReducers: builder => {
+        builder
+            .addCase(exports.joinGroupOrder.fulfilled, (state, action) => {
+            state.loading = 'idle';
+            state.error = null;
+            state.cartGuest = action.payload;
+        })
+            .addCase(exports.joinGroupOrder.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(exports.joinGroupOrder.rejected, (state, action) => {
+            state.loading = 'idle';
+            state.error = action.payload;
+        })
+            .addCase(exports.fetchGroupOrder.fulfilled, (state, action) => {
+            state = Object.assign(Object.assign(Object.assign({}, state), { loading: 'idle', error: null }), action.payload);
+        })
+            .addCase(exports.fetchGroupOrder.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(exports.fetchGroupOrder.rejected, (state, action) => {
+            state.loading = 'idle';
+            state.error = action.payload;
+        })
+            .addCase(exports.updateGroupOrder.fulfilled, (state, action) => {
+            state = Object.assign(Object.assign(Object.assign({}, state), { loading: 'idle', error: null }), action.payload);
+        })
+            .addCase(exports.updateGroupOrder.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(exports.updateGroupOrder.rejected, (state, action) => {
+            state.loading = 'idle';
+            state.error = action.payload;
+        })
+            .addCase(exports.reloadGuestOrder.fulfilled, state => {
+            state.loading = 'idle';
+        })
+            .addCase(exports.reloadGuestOrder.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(exports.reloadGuestOrder.rejected, (state, action) => {
+            state.loading = 'idle';
+            state.error = action.payload;
+        });
+    }
+});
+exports.resetGroupOrder = groupOrderSlice.actions.resetGroupOrder;
+const selectGroupOrder = (state) => state.groupOrder;
+exports.selectGroupOrder = selectGroupOrder;
+const selectGroupOrderToken = (state) => state.groupOrder.token;
+exports.selectGroupOrderToken = selectGroupOrderToken;
+const selectSpendingLimit = (state) => {
+    const { cartGuest, spendingLimit } = state.groupOrder;
+    return cartGuest && spendingLimit ? parseFloat(spendingLimit) : null;
+};
+exports.selectSpendingLimit = selectSpendingLimit;
+const selectGroupOrderClosed = (state) => {
+    const { cartGuest, cutoffAt, closed } = state.groupOrder;
+    const tz = (0, order_1.selectTimezone)(state);
+    const cutoffDate = cutoffAt ? (0, utils_1.isoToDate)(cutoffAt, tz) : null;
+    const pastCutoff = cutoffDate ? new Date() > cutoffDate : false;
+    return cartGuest && (closed || pastCutoff);
+};
+exports.selectGroupOrderClosed = selectGroupOrderClosed;
+const selectGroupOrderTests = (state) => {
+    const { closed, cutoffAt, guestLimit, guestCount } = state.groupOrder;
+    const tz = (0, order_1.selectTimezone)(state);
+    const cutoffDate = cutoffAt ? (0, utils_1.isoToDate)(cutoffAt, tz) : null;
+    const pastCutoff = cutoffDate ? new Date() > cutoffDate : false;
+    const spotsRemaining = guestLimit ? guestLimit - (guestCount !== null && guestCount !== void 0 ? guestCount : 0) : null;
+    const atCapacity = spotsRemaining !== null && spotsRemaining <= 0;
+    return { closed, pastCutoff, atCapacity };
+};
+exports.selectGroupOrderTests = selectGroupOrderTests;
+const selectGroupOrderPrepTimes = (state) => {
+    const { revenueCenter, serviceType } = state.order;
+    if (!revenueCenter || !serviceType)
+        return {};
+    const { settings } = revenueCenter;
+    const { wait_times, group_ordering } = settings || revenueCenter;
+    const { prep_time, lead_time: leadTime } = group_ordering || {};
+    const st = serviceType === 'WALKIN' ? 'PICKUP' : serviceType;
+    const waitTime = wait_times && wait_times[st] ? wait_times[st] : 0;
+    const prepTime = (waitTime !== null && waitTime !== void 0 ? waitTime : 0) + (prep_time !== null && prep_time !== void 0 ? prep_time : 0);
+    return { prepTime, leadTime };
+};
+exports.selectGroupOrderPrepTimes = selectGroupOrderPrepTimes;
+exports.groupOrderReducer = groupOrderSlice.reducer;