@open-tender/cloud 0.0.1

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

@@ -0,0 +1,86 @@
+import { AppState } from '../app';
+import { Order, Orders, OrdersCount, RequestError, RequestStatus } from '@open-tender/types';
+export interface OrdersState {
+    entities: Orders;
+    error: RequestError;
+    loading: RequestStatus;
+    skipped: number;
+    currentOrder: Order | null;
+    counts: OrdersCount;
+}
+export declare enum OrdersActionType {
+    FetchOrders = "orders/fetchOrders",
+    FetchOrdersToday = "orders/fetchOrdersToday",
+    PrintTicket = "order/printTicket",
+    UpdateOrders = "orders/updateOrders",
+    UpdateTicket = "orders/updateTicket",
+    PrintTickets = "orders/printTickets",
+    ResetTickets = "orders/resetTickets",
+    UpdateOrderPrep = "orders/updateOrderPrep",
+    PrintReceipt = "orders/printReceipt"
+}
+export declare const fetchOrders: import("@reduxjs/toolkit").AsyncThunk<any, any, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const printTicket: import("@reduxjs/toolkit").AsyncThunk<void, {
+    order_uuid: number;
+    ticket_no: number;
+    status: any;
+}, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const updateTicket: import("@reduxjs/toolkit").AsyncThunk<void, {
+    order_uuid: number;
+    ticket_no: number;
+    status: any;
+}, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const printTickets: import("@reduxjs/toolkit").AsyncThunk<void, {
+    order_uuid: number;
+    status: any;
+}, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const resetTickets: import("@reduxjs/toolkit").AsyncThunk<void, number, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const updateOrderPrep: import("@reduxjs/toolkit").AsyncThunk<void, {
+    order_uuid: number;
+    data: any;
+}, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const printReceipt: import("@reduxjs/toolkit").AsyncThunk<void, number, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const resetOrders: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>, setCurrentOrder: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, string>, skipFetchOrders: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>, updateOrder: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, string>;
+export declare const selectOrders: (state: AppState) => {
+    orders: Orders;
+    loading: RequestStatus;
+    error: RequestError;
+};
+export declare const selectCurrentOrder: (state: AppState) => Order | null;
+export declare const selectCurrentOrders: (state: AppState) => {
+    orders: Order[];
+    loading: RequestStatus;
+    error: RequestError;
+};
+export declare const selectFutureOrders: (state: AppState) => {
+    orders: Order[];
+    loading: RequestStatus;
+    error: RequestError;
+};
+export declare const selectOrdersCounts: (state: AppState) => {
+    current: any;
+    future: any;
+    qa: any;
+};
+export declare const ordersReducer: import("redux").Reducer<OrdersState, import("redux").AnyAction>;

package/dist/esm/slices/orders.js

@@ -0,0 +1,302 @@
+import { __awaiter } from "tslib";
+import { createAsyncThunk, createSlice } from '@reduxjs/toolkit';
+import { ReducerType } from './types';
+import { addAlert } from './alerts';
+import { currentLocalDate, isoToDate, makeOrdersCounts, notDone, parseIsoToDate, timezoneMap } from '@open-tender/utils';
+const initialState = {
+    entities: [],
+    loading: 'idle',
+    error: null,
+    skipped: 0,
+    currentOrder: null,
+    counts: { current: null, future: null, qa: null }
+};
+export var OrdersActionType;
+(function (OrdersActionType) {
+    OrdersActionType["FetchOrders"] = "orders/fetchOrders";
+    OrdersActionType["FetchOrdersToday"] = "orders/fetchOrdersToday";
+    OrdersActionType["PrintTicket"] = "order/printTicket";
+    OrdersActionType["UpdateOrders"] = "orders/updateOrders";
+    OrdersActionType["UpdateTicket"] = "orders/updateTicket";
+    OrdersActionType["PrintTickets"] = "orders/printTickets";
+    OrdersActionType["ResetTickets"] = "orders/resetTickets";
+    OrdersActionType["UpdateOrderPrep"] = "orders/updateOrderPrep";
+    OrdersActionType["PrintReceipt"] = "orders/printReceipt";
+})(OrdersActionType || (OrdersActionType = {}));
+export const fetchOrders = createAsyncThunk(OrdersActionType.FetchOrders, (args, { dispatch, getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    const { api, itemTypes } = getState().config;
+    if (!api)
+        return;
+    try {
+        const orders = yield api.getOrders(args);
+        const counts = makeOrdersCounts(itemTypes, orders);
+        return { orders, counts };
+    }
+    catch (err) {
+        const error = err;
+        dispatch(addAlert((error === null || error === void 0 ? void 0 : error.detail) || (error === null || error === void 0 ? void 0 : error.message)));
+        return rejectWithValue(error);
+    }
+}));
+// export const fetchOrdersToday = createAsyncThunk<
+//   any,
+//   any,
+//   { state: AppState; rejectValue: RequestError }
+// >(
+//   OrdersActionType.FetchOrdersToday,
+//   async (args, { dispatch, getState, rejectWithValue }) => {
+//     const { api, itemTypes, store } = getState().config
+//     if (!api || !store) return
+//     const tz: TimezonePython = store.timezone ? timezoneMap[store.timezone as TimezonePython] : getUserTimezone()
+//     const business_date = currentLocalDateStr(tz)
+//     const params = {
+//       business_date,
+//       prep_status: 'TODO,IN_PROGRESS,DONE',
+//       sort_by: 'fire_at',
+//       sort_direction: 'ASC',
+//       ...args
+//     }
+//     try {
+//       const ordersToday = await api.getOrders(params)
+//       const existing = getState().orders.entities.filter(
+//         i => !i.requested_at.startsWith(business_date)
+//       )
+//       const orders = [...ordersToday, ...existing]
+//         .map(i => ({
+//           ...i,
+//           fireAt: isoToDate(i.fire_at, tz)
+//         }))
+//         .sort((a, b) => a.fireAt - b.fireAt)
+//       const counts = makeOrdersCounts(itemTypes, orders)
+//       return { orders, counts }
+//     } catch (err) {
+//       const error = err as RequestError
+//       dispatch(addAlert(error?.detail || error?.message))
+//       return rejectWithValue(error)
+//     }
+//   }
+// )
+export const printTicket = createAsyncThunk(OrdersActionType.PrintTicket, (args, { dispatch, getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    const { api, itemTypes } = getState().config;
+    if (!api)
+        return;
+    try {
+        const data = args.status ? { ticket_status: args.status } : {};
+        const order = yield api.postTicketPrint(args.order_uuid, args.ticket_no, data);
+        dispatch(updateOrder({ order, itemTypes }));
+        return;
+    }
+    catch (err) {
+        const error = err;
+        dispatch(addAlert((error === null || error === void 0 ? void 0 : error.detail) || (error === null || error === void 0 ? void 0 : error.message)));
+        return rejectWithValue(error);
+    }
+}));
+export const updateTicket = createAsyncThunk(OrdersActionType.UpdateTicket, (args, { dispatch, getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    const { api, itemTypes } = getState().config;
+    if (!api)
+        return;
+    try {
+        const order = yield api.postTicketStatus(args.order_uuid, args.ticket_no, args.status);
+        dispatch(updateOrder({ order, itemTypes }));
+        return;
+    }
+    catch (err) {
+        const error = err;
+        dispatch(addAlert((error === null || error === void 0 ? void 0 : error.detail) || (error === null || error === void 0 ? void 0 : error.message)));
+        return rejectWithValue(error);
+    }
+}));
+export const printTickets = createAsyncThunk(OrdersActionType.PrintTickets, (args, { dispatch, getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    const { api, itemTypes } = getState().config;
+    if (!api)
+        return;
+    try {
+        const data = args.status ? { prep_status: args.status } : {};
+        const order = yield api.postTicketsPrint(args.order_uuid, data);
+        dispatch(updateOrder({ order, itemTypes }));
+        return;
+    }
+    catch (err) {
+        const error = err;
+        dispatch(addAlert((error === null || error === void 0 ? void 0 : error.detail) || (error === null || error === void 0 ? void 0 : error.message)));
+        return rejectWithValue(error);
+    }
+}));
+export const resetTickets = createAsyncThunk(OrdersActionType.ResetTickets, (order_uuid, { dispatch, getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    const { api, itemTypes } = getState().config;
+    if (!api)
+        return;
+    try {
+        const order = yield api.postTicketsReset(order_uuid);
+        dispatch(updateOrder({ order, itemTypes }));
+        return;
+    }
+    catch (err) {
+        const error = err;
+        dispatch(addAlert((error === null || error === void 0 ? void 0 : error.detail) || (error === null || error === void 0 ? void 0 : error.message)));
+        return rejectWithValue(error);
+    }
+}));
+export const updateOrderPrep = createAsyncThunk(OrdersActionType.UpdateOrderPrep, (args, { dispatch, getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    const { api, itemTypes } = getState().config;
+    if (!api)
+        return;
+    try {
+        const order = yield api.patchOrder(args.order_uuid, args.data);
+        dispatch(updateOrder({ order, itemTypes }));
+        return;
+    }
+    catch (err) {
+        const error = err;
+        dispatch(addAlert((error === null || error === void 0 ? void 0 : error.detail) || (error === null || error === void 0 ? void 0 : error.message)));
+        return rejectWithValue(error);
+    }
+}));
+export const printReceipt = createAsyncThunk(OrdersActionType.PrintReceipt, (order_uuid, { dispatch, getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    const { api } = getState().config;
+    if (!api)
+        return;
+    try {
+        yield api.postReceipt(order_uuid);
+        return;
+    }
+    catch (err) {
+        const error = err;
+        dispatch(addAlert((error === null || error === void 0 ? void 0 : error.detail) || (error === null || error === void 0 ? void 0 : error.message)));
+        return rejectWithValue(error);
+    }
+}));
+const ordersSlice = createSlice({
+    name: ReducerType.Orders,
+    initialState,
+    reducers: {
+        resetOrders: () => initialState,
+        setCurrentOrder: (state, action) => {
+            state.currentOrder = action.payload;
+        },
+        skipFetchOrders: state => {
+            state.skipped = state.skipped + 1;
+        },
+        updateOrder: (state, action) => {
+            const { order, itemTypes } = action.payload;
+            const entities = state.entities
+                .map(i => {
+                return i.order_uuid === order.order_uuid ? order : i;
+            })
+                .map(i => (Object.assign(Object.assign({}, i), { fireAt: parseIsoToDate(i.fire_at) })))
+                .sort((a, b) => a.fireAt - b.fireAt);
+            const counts = makeOrdersCounts(itemTypes, entities);
+            const currentOrder = state.currentOrder ? order : null;
+            state.entities = entities;
+            state.currentOrder = currentOrder;
+            state.counts = counts;
+        }
+    },
+    extraReducers: builder => {
+        builder
+            .addCase(fetchOrders.fulfilled, (state, action) => {
+            const { orders, counts } = action.payload;
+            state.entities = orders;
+            state.counts = counts;
+            state.loading = 'idle';
+            state.skipped = 0;
+        })
+            .addCase(fetchOrders.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(fetchOrders.rejected, state => {
+            state.loading = 'idle';
+        })
+            // .addCase(fetchOrdersToday.fulfilled, (state, action) => {
+            //   const { orders, counts } = action.payload
+            //   state.entities = orders
+            //   state.counts = counts
+            //   state.loading = 'idle'
+            // })
+            // .addCase(fetchOrdersToday.pending, state => {
+            //   state.loading = 'pending'
+            // })
+            // .addCase(fetchOrdersToday.rejected, state => {
+            //   state.loading = 'idle'
+            // })
+            .addCase(printTicket.fulfilled, state => {
+            state.loading = 'idle';
+        })
+            .addCase(printTicket.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(printTicket.rejected, state => {
+            state.loading = 'idle';
+        })
+            .addCase(updateTicket.fulfilled, state => {
+            state.loading = 'idle';
+        })
+            .addCase(updateTicket.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(updateTicket.rejected, state => {
+            state.loading = 'idle';
+        })
+            .addCase(printTickets.fulfilled, state => {
+            state.loading = 'idle';
+        })
+            .addCase(printTickets.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(printTickets.rejected, state => {
+            state.loading = 'idle';
+        })
+            .addCase(updateOrderPrep.fulfilled, state => {
+            state.loading = 'idle';
+        })
+            .addCase(updateOrderPrep.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(updateOrderPrep.rejected, state => {
+            state.loading = 'idle';
+        })
+            .addCase(printReceipt.fulfilled, state => {
+            state.loading = 'idle';
+        })
+            .addCase(printReceipt.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(printReceipt.rejected, state => {
+            state.loading = 'idle';
+        });
+    }
+});
+export const { resetOrders, setCurrentOrder, skipFetchOrders, updateOrder } = ordersSlice.actions;
+export const selectOrders = (state) => {
+    const { entities: orders, loading, error } = state.orders;
+    return { orders, loading, error };
+};
+export const selectCurrentOrder = (state) => {
+    return state.orders.currentOrder;
+};
+export const selectCurrentOrders = (state) => {
+    const { entities, loading, error } = state.orders;
+    const orders = entities.filter(i => {
+        const tz = timezoneMap[i.timezone];
+        const fireDate = isoToDate(i.fire_at, tz);
+        const currentDate = currentLocalDate(tz);
+        return notDone(i.prep_status) && fireDate < currentDate;
+    });
+    return { orders, loading, error };
+};
+export const selectFutureOrders = (state) => {
+    const { entities, loading, error } = state.orders;
+    const orders = entities.filter(i => {
+        const tz = timezoneMap[i.timezone];
+        const fireDate = isoToDate(i.fire_at, tz);
+        const currentDate = currentLocalDate(tz);
+        return notDone(i.prep_status) && fireDate > currentDate;
+    });
+    return { orders, loading, error };
+};
+export const selectOrdersCounts = (state) => {
+    const { current, future, qa } = state.orders.counts;
+    return { current, future, qa };
+};
+export const ordersReducer = ordersSlice.reducer;

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

@@ -0,0 +1,29 @@
+import { AppState } from '../app';
+import { RequestError, RequestStatus } from '@open-tender/types';
+export interface ResetPasswordState {
+    loading: RequestStatus;
+    error: RequestError;
+    success: boolean;
+    resetSent: boolean;
+}
+export declare enum ResetPasswordActionType {
+    SendPasswordResetEmail = "resetPassword/sendPasswordResetEmail",
+    ResetPassword = "resetPassword/resetPassword"
+}
+export declare const sendPasswordResetEmail: import("@reduxjs/toolkit").AsyncThunk<void, {
+    email: string;
+    link_url: string;
+}, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const resetPassword: import("@reduxjs/toolkit").AsyncThunk<void, {
+    new_password: string;
+    resetToken: string;
+}, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const resetPasswordReset: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
+export declare const selectResetPassword: (state: AppState) => ResetPasswordState;
+export declare const resetPasswordReducer: import("redux").Reducer<ResetPasswordState, import("redux").AnyAction>;

package/dist/esm/slices/resetPassword.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 = {
+    loading: 'idle',
+    error: null,
+    success: false,
+    resetSent: false
+};
+export var ResetPasswordActionType;
+(function (ResetPasswordActionType) {
+    ResetPasswordActionType["SendPasswordResetEmail"] = "resetPassword/sendPasswordResetEmail";
+    ResetPasswordActionType["ResetPassword"] = "resetPassword/resetPassword";
+})(ResetPasswordActionType || (ResetPasswordActionType = {}));
+export const sendPasswordResetEmail = createAsyncThunk(ResetPasswordActionType.SendPasswordResetEmail, (requestData, { getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    const { api } = getState().config;
+    if (!api)
+        return;
+    try {
+        yield api.postSendPasswordResetEmail(requestData.email, requestData.link_url);
+        return;
+    }
+    catch (err) {
+        const errors = makeFormErrors(err);
+        return rejectWithValue(errors);
+    }
+}));
+export const resetPassword = createAsyncThunk(ResetPasswordActionType.ResetPassword, (requestData, { getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    const { api } = getState().config;
+    if (!api)
+        return;
+    try {
+        yield api.postResetPassword(requestData.new_password, requestData.resetToken);
+        return;
+    }
+    catch (err) {
+        const errors = makeFormErrors(err);
+        return rejectWithValue(errors);
+    }
+}));
+const resetPasswordSlice = createSlice({
+    name: ReducerType.ResetPassword,
+    initialState,
+    reducers: {
+        resetPasswordReset: () => initialState
+    },
+    extraReducers: builder => {
+        builder
+            .addCase(sendPasswordResetEmail.fulfilled, state => {
+            state.resetSent = true;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(sendPasswordResetEmail.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(sendPasswordResetEmail.rejected, (state, action) => {
+            state.loading = 'idle';
+            state.error = action.payload;
+        })
+            .addCase(resetPassword.fulfilled, state => {
+            state.resetSent = false;
+            state.success = true;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(resetPassword.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(resetPassword.rejected, (state, action) => {
+            state.loading = 'idle';
+            state.error = action.payload;
+        });
+    }
+});
+export const { resetPasswordReset } = resetPasswordSlice.actions;
+export const selectResetPassword = (state) => state.resetPassword;
+export const resetPasswordReducer = resetPasswordSlice.reducer;

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

@@ -0,0 +1,35 @@
+import { AppState } from '../app';
+import { CustomerRevenueCenters, RequestError, RequestStatus } from '@open-tender/types';
+export interface RevenueCentersState {
+    revenueCenters: CustomerRevenueCenters;
+    error: RequestError;
+    loading: RequestStatus;
+}
+export declare enum RevenueCentersActionType {
+    FetchRevenueCenters = "revenueCenters/fetchRevenueCenters",
+    FetchLocations = "revenueCenters/fetchLocations"
+}
+export declare const fetchRevenueCenters: import("@reduxjs/toolkit").AsyncThunk<CustomerRevenueCenters, {
+    type: string;
+    is_outpost: boolean;
+    lat: number;
+    lng: number;
+    requestedAt: string;
+}, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const fetchLocations: import("@reduxjs/toolkit").AsyncThunk<CustomerRevenueCenters, {
+    type: string;
+    is_outpost: boolean;
+    lat: number;
+    lng: number;
+    requestedAt: string;
+}, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const resetRevenueCenters: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>, setRevenueCenters: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, string>;
+export declare const selectRevenueCenters: (state: AppState) => RevenueCentersState;
+export declare const selectRevenueCenterCount: (state: AppState) => number;
+export declare const revenueCentersReducer: import("redux").Reducer<RevenueCentersState, import("redux").AnyAction>;

package/dist/esm/slices/revenueCenters.js

@@ -0,0 +1,89 @@
+import { __awaiter } from "tslib";
+import { createAsyncThunk, createSlice } from '@reduxjs/toolkit';
+import { ReducerType } from './types';
+import { addDistance } from '@open-tender/utils';
+const initialState = {
+    revenueCenters: [],
+    loading: 'idle',
+    error: null
+};
+export var RevenueCentersActionType;
+(function (RevenueCentersActionType) {
+    RevenueCentersActionType["FetchRevenueCenters"] = "revenueCenters/fetchRevenueCenters";
+    RevenueCentersActionType["FetchLocations"] = "revenueCenters/fetchLocations";
+})(RevenueCentersActionType || (RevenueCentersActionType = {}));
+export const fetchRevenueCenters = createAsyncThunk(RevenueCentersActionType.FetchRevenueCenters, (requestData, { getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const { api } = getState().config;
+        if (requestData.lat)
+            requestData.lat = parseFloat(requestData.lat.toFixed(7));
+        if (requestData.lng)
+            requestData.lng = parseFloat(requestData.lng.toFixed(7));
+        const { data } = yield api.getRevenueCenters(requestData.type, requestData.is_outpost, requestData.lat, requestData.lng, requestData.requestedAt);
+        const revenueCenters = requestData.lat && requestData.lng
+            ? addDistance(data, { lat: requestData.lat, lng: requestData.lng })
+            : data;
+        return revenueCenters;
+    }
+    catch (err) {
+        return rejectWithValue(err);
+    }
+}));
+export const fetchLocations = createAsyncThunk(RevenueCentersActionType.FetchLocations, (requestData, { getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const { api } = getState().config;
+        if (requestData.lat)
+            requestData.lat = parseFloat(requestData.lat.toFixed(7));
+        if (requestData.lng)
+            requestData.lng = parseFloat(requestData.lng.toFixed(7));
+        const { data } = yield api.getLocations(requestData.type, requestData.is_outpost, requestData.lat, requestData.lng, requestData.requestedAt);
+        const revenueCenters = requestData.lat && requestData.lng
+            ? addDistance(data, { lat: requestData.lat, lng: requestData.lng })
+            : data;
+        return revenueCenters;
+    }
+    catch (err) {
+        return rejectWithValue(err);
+    }
+}));
+const revenueCentersSlice = createSlice({
+    name: ReducerType.RevenueCenters,
+    initialState,
+    reducers: {
+        resetRevenueCenters: () => initialState,
+        setRevenueCenters: (state, action) => {
+            state.revenueCenters = action.payload;
+        }
+    },
+    extraReducers: builder => {
+        builder
+            .addCase(fetchRevenueCenters.fulfilled, (state, action) => {
+            state.revenueCenters = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(fetchRevenueCenters.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(fetchRevenueCenters.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        })
+            .addCase(fetchLocations.fulfilled, (state, action) => {
+            state.revenueCenters = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(fetchLocations.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(fetchLocations.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        });
+    }
+});
+export const { resetRevenueCenters, setRevenueCenters } = revenueCentersSlice.actions;
+export const selectRevenueCenters = (state) => state.revenueCenters;
+export const selectRevenueCenterCount = (state) => state.revenueCenters ? state.revenueCenters.revenueCenters.length : 0;
+export const revenueCentersReducer = revenueCentersSlice.reducer;

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

@@ -0,0 +1,19 @@
+import { AppState } from '../app';
+import { LoginData, RequestError, RequestStatus } from '@open-tender/types';
+export interface SignUpState {
+    loading: RequestStatus;
+    error: RequestError;
+}
+export declare enum SignUpActionType {
+    SignUpCustomer = "signUp/signUpCustomer"
+}
+export declare const signUpCustomer: import("@reduxjs/toolkit").AsyncThunk<void, {
+    data: LoginData;
+    callback?: ((data: any) => void) | undefined;
+}, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const resetSignUp: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
+export declare const selectSignUp: (state: AppState) => SignUpState;
+export declare const signUpReducer: import("redux").Reducer<SignUpState, import("redux").AnyAction>;