@open-tender/cloud 0.0.1

package/dist/esm/slices/order.js

@@ -0,0 +1,423 @@
+import { __awaiter } from "tslib";
+import { createAsyncThunk, createSlice } from '@reduxjs/toolkit';
+import { ReducerType } from './types';
+import { addItem, calcCartCounts, decrementItem, getUserTimezone, incrementItem, makeFirstRequestedAt, makeFirstTimes, makeRandomNumberString, makeRequestedAtStr, rehydrateCart, rehydrateCheckoutForm, removeItem, timezoneMap } from '@open-tender/utils';
+import { updateForm } from './checkout';
+import { resetMenuVars } from './menu';
+import { setMenuItems } from './menuItems';
+const initialState = {
+    orderId: null,
+    orderType: null,
+    serviceType: null,
+    deviceType: null,
+    isOutpost: false,
+    isCurbside: false,
+    revenueCenter: null,
+    table: null,
+    prepType: null,
+    requestedAt: 'asap',
+    address: null,
+    currentCategory: null,
+    currentItem: null,
+    cart: [],
+    cartCounts: {},
+    messages: [],
+    alert: null,
+    error: null,
+    loading: 'idle',
+    currentVendor: null
+};
+export var OrderActionType;
+(function (OrderActionType) {
+    OrderActionType["FetchRevenueCenter"] = "order/fetchRevenueCenter";
+    OrderActionType["FetchLocation"] = "order/fetchLocation";
+    OrderActionType["RevertMenu"] = "order/revertMenu";
+    OrderActionType["RefreshRevenueCenter"] = "order/refreshRevenueCenter";
+    OrderActionType["EditOrder"] = "order/editOrder";
+    OrderActionType["ReorderPastOrder"] = "order/reorderPastOrder";
+})(OrderActionType || (OrderActionType = {}));
+export const fetchRevenueCenter = createAsyncThunk(OrderActionType.FetchRevenueCenter, (requestData, { dispatch, getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    const { api } = getState().config;
+    if (!api)
+        return;
+    try {
+        const revenueCenter = yield api.getRevenueCenter(requestData.revenueCenterId, requestData.requestedAt);
+        dispatch(setRevenueCenter(revenueCenter));
+        return revenueCenter;
+    }
+    catch (err) {
+        return rejectWithValue(err);
+    }
+}));
+export const fetchLocation = createAsyncThunk(OrderActionType.FetchLocation, (revenueCenterId, { dispatch, getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    const { api } = getState().config;
+    if (!api)
+        return;
+    try {
+        const revenueCenter = yield api.getLocation(revenueCenterId);
+        dispatch(setRevenueCenter(revenueCenter));
+        return revenueCenter;
+    }
+    catch (err) {
+        return rejectWithValue(err);
+    }
+}));
+export const revertMenu = createAsyncThunk(OrderActionType.RevertMenu, (requestData, { dispatch, getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    const { api } = getState().config;
+    if (!api)
+        return;
+    try {
+        const revenueCenter = yield api.getLocation(requestData.revenueCenterId);
+        dispatch(setMenuVars({
+            revenueCenter,
+            serviceType: requestData.serviceType,
+            requestedAt: requestData.requestedAt
+        }));
+        return revenueCenter;
+    }
+    catch (err) {
+        return rejectWithValue(err);
+    }
+}));
+export const refreshRevenueCenter = createAsyncThunk(OrderActionType.RefreshRevenueCenter, (requestData, { getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b;
+    const { api } = getState().config;
+    if (!api)
+        return;
+    try {
+        const revenueCenter = yield api.getLocation(requestData.revenueCenterId);
+        if (requestData.reset)
+            requestData.requestedAt = null;
+        const firstTimes = makeFirstTimes(revenueCenter, (_a = requestData.serviceType) !== null && _a !== void 0 ? _a : "WALKIN", ((_b = requestData.requestedAt) !== null && _b !== void 0 ? _b : new Date().toISOString()));
+        const { status } = revenueCenter;
+        let alert;
+        if (!firstTimes || status !== 'OPEN') {
+            alert = { type: 'closed', args: { status, preventClose: true } };
+        }
+        else {
+            alert = {
+                type: 'adjustRequestedAt',
+                args: { firstTimes, revenueCenter, preventClose: true }
+            };
+        }
+        return alert;
+    }
+    catch (err) {
+        return rejectWithValue(err);
+    }
+}));
+export const editOrder = createAsyncThunk(OrderActionType.EditOrder, (order, { dispatch, getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    const { api } = getState().config;
+    if (!api)
+        return;
+    const alert = { type: 'working', args: { text: 'Building your order...' } };
+    dispatch(setAlert(alert));
+    try {
+        const { order_id: orderId, order_type: orderType, service_type: serviceType, requested_at: requestedAt, revenue_center, address } = order;
+        const revenueCenterId = revenue_center === null || revenue_center === void 0 ? void 0 : revenue_center.revenue_center_id;
+        const revenueCenter = yield api.getLocation(revenueCenterId);
+        const menuItems = yield api.getMenuItems(revenueCenterId, serviceType);
+        const { cart, cartCounts } = rehydrateCart(menuItems, order.cart);
+        dispatch(setMenuItems(menuItems));
+        const form = rehydrateCheckoutForm(order);
+        dispatch(updateForm(form));
+        // dispatch(toggleSidebar())
+        const isOutpost = revenueCenter.is_outpost;
+        const payload = {
+            orderId,
+            orderType,
+            serviceType,
+            isOutpost,
+            revenueCenter,
+            requestedAt,
+            address,
+            cart: cart,
+            cartCounts
+        };
+        dispatch(setAlert({ type: 'closeAndSidebar' }));
+        return payload;
+    }
+    catch (err) {
+        dispatch(resetAlert());
+        dispatch(addMessage('Something went wrong. Please contact support.'));
+        return rejectWithValue(null);
+    }
+}));
+export const reorderPastOrder = createAsyncThunk(OrderActionType.ReorderPastOrder, (requestData, { dispatch, getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    const { api } = getState().config;
+    if (!api)
+        return;
+    const alert = { type: 'working', args: { text: 'Building your order...' } };
+    dispatch(setAlert(alert));
+    try {
+        const revenueCenter = yield api.getLocation(requestData.revenueCenterId);
+        const requestedAt = makeFirstRequestedAt(revenueCenter, requestData.serviceType, null);
+        if (!requestedAt) {
+            const { status } = revenueCenter;
+            const alert = { type: 'closed', args: { status, isCancel: true } };
+            dispatch(setAlert(alert));
+            return {};
+        }
+        else {
+            dispatch(resetMenuVars());
+            dispatch(resetRevenueCenter());
+            const menuItems = yield api.getMenuItems(requestData.revenueCenterId, requestData.serviceType);
+            const { cart, cartCounts } = rehydrateCart(menuItems, requestData.items);
+            dispatch(setMenuItems(menuItems));
+            const orderType = revenueCenter.revenue_center_type;
+            const payload = {
+                revenueCenter,
+                requestedAt,
+                serviceType: requestData.serviceType,
+                cart,
+                cartCounts
+            };
+            const alert = {
+                type: 'requestedAt',
+                args: {
+                    openSidebar: true,
+                    focusFirst: true,
+                    skipClose: true,
+                    isReorder: true,
+                    revenueCenter,
+                    serviceType: requestData.serviceType,
+                    orderType,
+                    requestedAt
+                }
+            };
+            dispatch(setAlert(alert));
+            return payload;
+        }
+    }
+    catch (err) {
+        dispatch(resetAlert());
+        dispatch(addMessage('Something went wrong. Please contact support.'));
+        return rejectWithValue(null);
+    }
+}));
+const orderSlice = createSlice({
+    name: ReducerType.Order,
+    initialState,
+    reducers: {
+        resetOrder: () => initialState,
+        resetOrderType: state => {
+            state.orderId = null;
+            state.orderType = null;
+            state.serviceType = null;
+            state.prepType = null;
+            state.isOutpost = false;
+            state.isCurbside = false;
+            state.revenueCenter = null;
+            state.table = null;
+            state.requestedAt = null;
+        },
+        resetRevenueCenter: state => {
+            state.revenueCenter = null;
+        },
+        resetLocation: state => {
+            state.revenueCenter = null;
+        },
+        resetCart: state => {
+            state.cart = null;
+            state.cartCounts = null;
+        },
+        resetMessages: state => {
+            state.messages = [];
+        },
+        resetAlert: state => {
+            state.alert = null;
+        },
+        // updateOrder: (state, action) => {
+        //   state.alert = action.payload
+        // },
+        setAlert: (state, action) => {
+            state.alert = action.payload;
+        },
+        setOrderId: (state, action) => {
+            state.orderId = action.payload;
+        },
+        setOrderType: (state, action) => {
+            state.orderType = action.payload;
+        },
+        setServiceType: (state, action) => {
+            state.serviceType = action.payload;
+        },
+        setOrderServiceType: (state, action) => {
+            state = Object.assign(Object.assign({}, state), action.payload);
+        },
+        setCurbside: (state, action) => {
+            state.isCurbside = action.payload;
+        },
+        setDeviceType: (state, action) => {
+            state.deviceType = action.payload;
+        },
+        setMenuVars: (state, action) => {
+            const { revenueCenter } = action.payload;
+            state = Object.assign(Object.assign(Object.assign({}, state), action.payload), { orderType: revenueCenter.revenue_center_type, isOutpost: revenueCenter.is_outpost });
+        },
+        setAddress: (state, action) => {
+            state.address = action.payload;
+        },
+        setRequestedAt: (state, action) => {
+            const messages = state.messages.filter(i => !i.message.includes('Requested time'));
+            state.requestedAt = action.payload;
+            state.messages = messages;
+        },
+        setRevenueCenter: (state, action) => {
+            const revenueCenter = action.payload;
+            const previousRequestedAt = state.requestedAt;
+            const requestedAt = makeFirstRequestedAt(revenueCenter, state.serviceType, previousRequestedAt);
+            let messages;
+            if (previousRequestedAt && requestedAt !== previousRequestedAt) {
+                const otherMessages = state.messages.filter(i => !i.message.includes('Requested time'));
+                const tz = timezoneMap[revenueCenter.timezone];
+                const requestedAtText = makeRequestedAtStr(requestedAt, tz);
+                const msg = {
+                    message: `Requested time updated to ${requestedAtText}`,
+                    id: makeRandomNumberString()
+                };
+                messages = [msg, ...otherMessages];
+            }
+            else {
+                messages = state.messages;
+            }
+            state.revenueCenter = revenueCenter;
+            state.requestedAt = requestedAt !== null && requestedAt !== void 0 ? requestedAt : null;
+            state.messages = messages;
+        },
+        setTable: (state, action) => {
+            state.table = action.payload;
+        },
+        setPrepType: (state, action) => {
+            state.prepType = action.payload;
+        },
+        setCart: (state, action) => {
+            const cartCounts = calcCartCounts(action.payload);
+            state.cart = action.payload;
+            state.cartCounts = cartCounts;
+        },
+        setCurrentCategory: (state, action) => {
+            state.currentCategory = action.payload;
+        },
+        addItemToCart: (state, action) => {
+            const currentCart = state.cart !== null ? state.cart : [];
+            const { cart, cartCounts } = addItem([...currentCart], action.payload);
+            state.cart = cart;
+            state.cartCounts = cartCounts;
+        },
+        removeItemFromCart: (state, action) => {
+            const { index } = action.payload;
+            const currentCart = state.cart !== null ? state.cart : [];
+            const { cart, cartCounts } = removeItem([...currentCart], index);
+            state.cart = cart;
+            state.cartCounts = cartCounts;
+        },
+        incrementItemInCart: (state, action) => {
+            const { index } = action.payload;
+            const currentCart = state.cart !== null ? state.cart : [];
+            const { cart, cartCounts } = incrementItem([...currentCart], index);
+            state.cart = cart;
+            state.cartCounts = cartCounts;
+        },
+        decrementItemInCart: (state, action) => {
+            const { index } = action.payload;
+            const currentCart = state.cart !== null ? state.cart : [];
+            const { cart, cartCounts } = decrementItem([...currentCart], index);
+            state.cart = cart;
+            state.cartCounts = cartCounts;
+        },
+        addMessage: (state, action) => {
+            const existing = state.messages.map(i => i.message);
+            if (existing.includes(action.payload)) {
+                // do nothing
+                return;
+            }
+            state.messages = [
+                ...state.messages,
+                {
+                    message: action.payload,
+                    id: makeRandomNumberString()
+                }
+            ];
+        },
+        removeMessage: (state, action) => {
+            state.messages = state.messages.filter(i => i.id !== action.payload);
+        }
+    },
+    extraReducers: builder => {
+        builder
+            .addCase(fetchRevenueCenter.fulfilled, state => {
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(fetchRevenueCenter.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(fetchRevenueCenter.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        })
+            .addCase(fetchLocation.fulfilled, state => {
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(fetchLocation.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(fetchLocation.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        })
+            .addCase(revertMenu.fulfilled, state => {
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(revertMenu.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(revertMenu.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        })
+            .addCase(refreshRevenueCenter.fulfilled, (state, action) => {
+            state.alert = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(refreshRevenueCenter.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(refreshRevenueCenter.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        })
+            .addCase(editOrder.fulfilled, (state, action) => {
+            state = Object.assign(Object.assign(Object.assign({}, state), action.payload), { loading: 'idle', error: null });
+        })
+            .addCase(editOrder.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(editOrder.rejected, state => {
+            state.loading = 'idle';
+        })
+            .addCase(reorderPastOrder.fulfilled, (state, action) => {
+            state = Object.assign(Object.assign(Object.assign({}, state), action.payload), { loading: 'idle', error: null });
+        })
+            .addCase(reorderPastOrder.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(reorderPastOrder.rejected, state => {
+            state.loading = 'idle';
+        });
+    }
+});
+export const { resetOrder, addItemToCart, addMessage, decrementItemInCart, incrementItemInCart, removeItemFromCart, removeMessage, resetAlert, resetCart, resetLocation, resetMessages, resetOrderType, resetRevenueCenter, setAddress, setAlert, setCart, setCurbside, setCurrentCategory, setDeviceType, setMenuVars, setOrderId, setOrderServiceType, setOrderType, setPrepType, setRequestedAt, setRevenueCenter, setServiceType, setTable,
+// updateOrder
+ } = orderSlice.actions;
+export const selectTimezone = (state) => {
+    var _a;
+    return state.order.revenueCenter
+        ? timezoneMap[(_a = state.order.revenueCenter.timezone) !== null && _a !== void 0 ? _a : 'US/Central']
+        : getUserTimezone();
+};
+export const orderReducer = orderSlice.reducer;

package/dist/esm/slices/orderFulfillment.d.ts

@@ -0,0 +1,29 @@
+import { AppState } from '../app';
+import { OrderFulfillment, RequestError, RequestStatus } from '@open-tender/types';
+export interface OrderFulfillmentState {
+    orderFulfillment: OrderFulfillment | null;
+    error: RequestError;
+    loading: RequestStatus;
+}
+export declare enum OrderFulfillmentActionType {
+    FetchOrderFulfillment = "orderFulfillment/fetchOrderFulfillment",
+    UpdateOrderFulfillment = "orderFulfillment/updateOrderFulfillment"
+}
+export declare const fetchOrderFulfillment: import("@reduxjs/toolkit").AsyncThunk<OrderFulfillment, number, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const updateOrderFulfillment: import("@reduxjs/toolkit").AsyncThunk<OrderFulfillment, {
+    orderId: number;
+    data: OrderFulfillment;
+}, {
+    state: AppState;
+    rejectValue: any;
+}>;
+export declare const resetOrderFulfillment: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
+export declare const selectOrderFulfillment: (state: AppState) => {
+    orderFulfillment: OrderFulfillment | null;
+    loading: RequestStatus;
+    error: RequestError;
+};
+export declare const orderFulfillmentReducer: import("redux").Reducer<OrderFulfillmentState, import("redux").AnyAction>;

package/dist/esm/slices/orderFulfillment.js

@@ -0,0 +1,79 @@
+import { __awaiter } from "tslib";
+import { createAsyncThunk, createSlice } from '@reduxjs/toolkit';
+import { ReducerType } from './types';
+import { makeFormErrors } from '@open-tender/utils';
+const initialState = {
+    orderFulfillment: null,
+    loading: 'idle',
+    error: null
+};
+export var OrderFulfillmentActionType;
+(function (OrderFulfillmentActionType) {
+    OrderFulfillmentActionType["FetchOrderFulfillment"] = "orderFulfillment/fetchOrderFulfillment";
+    OrderFulfillmentActionType["UpdateOrderFulfillment"] = "orderFulfillment/updateOrderFulfillment";
+})(OrderFulfillmentActionType || (OrderFulfillmentActionType = {}));
+export const fetchOrderFulfillment = createAsyncThunk(OrderFulfillmentActionType.FetchOrderFulfillment, (orderId, { getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    const { api } = getState().config;
+    if (!api)
+        return;
+    try {
+        const response = yield api.getOrderFulfillment(orderId);
+        return response;
+    }
+    catch (err) {
+        return rejectWithValue(err);
+    }
+}));
+export const updateOrderFulfillment = createAsyncThunk(OrderFulfillmentActionType.UpdateOrderFulfillment, (requestData, { getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    const { api } = getState().config;
+    if (!api)
+        return;
+    try {
+        const response = yield api.putOrderFulfillment(requestData.orderId, requestData.data);
+        return response;
+    }
+    catch (err) {
+        const errors = makeFormErrors(err);
+        return rejectWithValue(errors);
+    }
+}));
+const orderFulfillmentSlice = createSlice({
+    name: ReducerType.OrderFulfillment,
+    initialState,
+    reducers: {
+        resetOrderFulfillment: () => initialState
+    },
+    extraReducers: builder => {
+        builder
+            .addCase(fetchOrderFulfillment.fulfilled, (state, action) => {
+            state.orderFulfillment = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(fetchOrderFulfillment.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(fetchOrderFulfillment.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        })
+            .addCase(updateOrderFulfillment.fulfilled, (state, action) => {
+            state.orderFulfillment = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(updateOrderFulfillment.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(updateOrderFulfillment.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        });
+    }
+});
+export const { resetOrderFulfillment } = orderFulfillmentSlice.actions;
+export const selectOrderFulfillment = (state) => {
+    const { orderFulfillment, loading, error } = state.orderFulfillment;
+    return { orderFulfillment, loading, error };
+};
+export const orderFulfillmentReducer = orderFulfillmentSlice.reducer;

package/dist/esm/slices/orderRating.d.ts

@@ -0,0 +1,34 @@
+import { AppState } from '../app';
+import { OrderRating, RequestError, RequestStatus } from '@open-tender/types';
+export interface OrderRatingState {
+    orderRating: OrderRating | null;
+    error: RequestError;
+    loading: RequestStatus;
+}
+export declare enum OrderRatingActionType {
+    FetchOrderRating = "orderRating/fetchOrderRating",
+    UpdateOrderRating = "orderRating/updateOrderRating",
+    UnsubscribeOrderRating = "orderRating/unsubscribeOrderRating"
+}
+export declare const fetchOrderRating: import("@reduxjs/toolkit").AsyncThunk<OrderRating, number, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const updateOrderRating: import("@reduxjs/toolkit").AsyncThunk<OrderRating, {
+    orderId: number;
+    data: OrderRating;
+}, {
+    state: AppState;
+    rejectValue: any;
+}>;
+export declare const unsubscribeOrderRating: import("@reduxjs/toolkit").AsyncThunk<void, number, {
+    state: AppState;
+    rejectValue: any;
+}>;
+export declare const resetOrderRating: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
+export declare const selectOrderRating: (state: AppState) => {
+    orderRating: OrderRating | null;
+    loading: RequestStatus;
+    error: RequestError;
+};
+export declare const orderRatingReducer: import("redux").Reducer<OrderRatingState, import("redux").AnyAction>;

package/dist/esm/slices/orderRating.js

@@ -0,0 +1,104 @@
+import { __awaiter } from "tslib";
+import { createAsyncThunk, createSlice } from '@reduxjs/toolkit';
+import { ReducerType } from './types';
+import { makeFormErrors } from '@open-tender/utils';
+const initialState = {
+    orderRating: null,
+    loading: 'idle',
+    error: null
+};
+export var OrderRatingActionType;
+(function (OrderRatingActionType) {
+    OrderRatingActionType["FetchOrderRating"] = "orderRating/fetchOrderRating";
+    OrderRatingActionType["UpdateOrderRating"] = "orderRating/updateOrderRating";
+    OrderRatingActionType["UnsubscribeOrderRating"] = "orderRating/unsubscribeOrderRating";
+})(OrderRatingActionType || (OrderRatingActionType = {}));
+export const fetchOrderRating = createAsyncThunk(OrderRatingActionType.FetchOrderRating, (ratingUuid, { getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    const { api } = getState().config;
+    if (!api)
+        return;
+    try {
+        const response = yield api.getOrderRating(ratingUuid);
+        return response;
+    }
+    catch (err) {
+        return rejectWithValue(err);
+    }
+}));
+export const updateOrderRating = createAsyncThunk(OrderRatingActionType.UpdateOrderRating, (requestData, { getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    const { api } = getState().config;
+    if (!api)
+        return;
+    try {
+        const response = yield api.putOrderRating(requestData.orderId, requestData.data);
+        return response;
+    }
+    catch (err) {
+        const errors = makeFormErrors(err);
+        return rejectWithValue(errors);
+    }
+}));
+export const unsubscribeOrderRating = createAsyncThunk(OrderRatingActionType.UnsubscribeOrderRating, (ratingUuid, { getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    const { api } = getState().config;
+    if (!api)
+        return;
+    try {
+        yield api.postOrderRatingUnsubscribe(ratingUuid);
+        return;
+    }
+    catch (err) {
+        return rejectWithValue(err);
+    }
+}));
+const orderRatingSlice = createSlice({
+    name: ReducerType.OrderRating,
+    initialState,
+    reducers: {
+        resetOrderRating: () => initialState
+    },
+    extraReducers: builder => {
+        builder
+            .addCase(fetchOrderRating.fulfilled, (state, action) => {
+            state.orderRating = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(fetchOrderRating.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(fetchOrderRating.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        })
+            .addCase(updateOrderRating.fulfilled, (state, action) => {
+            state.orderRating = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(updateOrderRating.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(updateOrderRating.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        })
+            .addCase(unsubscribeOrderRating.fulfilled, state => {
+            state.orderRating = null;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(unsubscribeOrderRating.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(unsubscribeOrderRating.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        });
+    }
+});
+export const { resetOrderRating } = orderRatingSlice.actions;
+export const selectOrderRating = (state) => {
+    const { orderRating, loading, error } = state.orderRating;
+    return { orderRating, loading, error };
+};
+export const orderRatingReducer = orderRatingSlice.reducer;