@open-tender/cloud 0.0.1

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

@@ -0,0 +1,311 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ordersReducer = exports.selectOrdersCounts = exports.selectFutureOrders = exports.selectCurrentOrders = exports.selectCurrentOrder = exports.selectOrders = exports.updateOrder = exports.skipFetchOrders = exports.setCurrentOrder = exports.resetOrders = exports.printReceipt = exports.updateOrderPrep = exports.resetTickets = exports.printTickets = exports.updateTicket = exports.printTicket = exports.fetchOrders = exports.OrdersActionType = void 0;
+const tslib_1 = require("tslib");
+const toolkit_1 = require("@reduxjs/toolkit");
+const types_1 = require("./types");
+const alerts_1 = require("./alerts");
+const utils_1 = require("@open-tender/utils");
+const initialState = {
+    entities: [],
+    loading: 'idle',
+    error: null,
+    skipped: 0,
+    currentOrder: null,
+    counts: { current: null, future: null, qa: null }
+};
+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 = exports.OrdersActionType || (exports.OrdersActionType = {}));
+exports.fetchOrders = (0, toolkit_1.createAsyncThunk)(OrdersActionType.FetchOrders, (args, { dispatch, getState, rejectWithValue }) => tslib_1.__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 = (0, utils_1.makeOrdersCounts)(itemTypes, orders);
+        return { orders, counts };
+    }
+    catch (err) {
+        const error = err;
+        dispatch((0, alerts_1.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)
+//     }
+//   }
+// )
+exports.printTicket = (0, toolkit_1.createAsyncThunk)(OrdersActionType.PrintTicket, (args, { dispatch, getState, rejectWithValue }) => tslib_1.__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((0, exports.updateOrder)({ order, itemTypes }));
+        return;
+    }
+    catch (err) {
+        const error = err;
+        dispatch((0, alerts_1.addAlert)((error === null || error === void 0 ? void 0 : error.detail) || (error === null || error === void 0 ? void 0 : error.message)));
+        return rejectWithValue(error);
+    }
+}));
+exports.updateTicket = (0, toolkit_1.createAsyncThunk)(OrdersActionType.UpdateTicket, (args, { dispatch, getState, rejectWithValue }) => tslib_1.__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((0, exports.updateOrder)({ order, itemTypes }));
+        return;
+    }
+    catch (err) {
+        const error = err;
+        dispatch((0, alerts_1.addAlert)((error === null || error === void 0 ? void 0 : error.detail) || (error === null || error === void 0 ? void 0 : error.message)));
+        return rejectWithValue(error);
+    }
+}));
+exports.printTickets = (0, toolkit_1.createAsyncThunk)(OrdersActionType.PrintTickets, (args, { dispatch, getState, rejectWithValue }) => tslib_1.__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((0, exports.updateOrder)({ order, itemTypes }));
+        return;
+    }
+    catch (err) {
+        const error = err;
+        dispatch((0, alerts_1.addAlert)((error === null || error === void 0 ? void 0 : error.detail) || (error === null || error === void 0 ? void 0 : error.message)));
+        return rejectWithValue(error);
+    }
+}));
+exports.resetTickets = (0, toolkit_1.createAsyncThunk)(OrdersActionType.ResetTickets, (order_uuid, { dispatch, getState, rejectWithValue }) => tslib_1.__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((0, exports.updateOrder)({ order, itemTypes }));
+        return;
+    }
+    catch (err) {
+        const error = err;
+        dispatch((0, alerts_1.addAlert)((error === null || error === void 0 ? void 0 : error.detail) || (error === null || error === void 0 ? void 0 : error.message)));
+        return rejectWithValue(error);
+    }
+}));
+exports.updateOrderPrep = (0, toolkit_1.createAsyncThunk)(OrdersActionType.UpdateOrderPrep, (args, { dispatch, getState, rejectWithValue }) => tslib_1.__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((0, exports.updateOrder)({ order, itemTypes }));
+        return;
+    }
+    catch (err) {
+        const error = err;
+        dispatch((0, alerts_1.addAlert)((error === null || error === void 0 ? void 0 : error.detail) || (error === null || error === void 0 ? void 0 : error.message)));
+        return rejectWithValue(error);
+    }
+}));
+exports.printReceipt = (0, toolkit_1.createAsyncThunk)(OrdersActionType.PrintReceipt, (order_uuid, { dispatch, getState, rejectWithValue }) => tslib_1.__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((0, alerts_1.addAlert)((error === null || error === void 0 ? void 0 : error.detail) || (error === null || error === void 0 ? void 0 : error.message)));
+        return rejectWithValue(error);
+    }
+}));
+const ordersSlice = (0, toolkit_1.createSlice)({
+    name: types_1.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: (0, utils_1.parseIsoToDate)(i.fire_at) })))
+                .sort((a, b) => a.fireAt - b.fireAt);
+            const counts = (0, utils_1.makeOrdersCounts)(itemTypes, entities);
+            const currentOrder = state.currentOrder ? order : null;
+            state.entities = entities;
+            state.currentOrder = currentOrder;
+            state.counts = counts;
+        }
+    },
+    extraReducers: builder => {
+        builder
+            .addCase(exports.fetchOrders.fulfilled, (state, action) => {
+            const { orders, counts } = action.payload;
+            state.entities = orders;
+            state.counts = counts;
+            state.loading = 'idle';
+            state.skipped = 0;
+        })
+            .addCase(exports.fetchOrders.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(exports.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(exports.printTicket.fulfilled, state => {
+            state.loading = 'idle';
+        })
+            .addCase(exports.printTicket.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(exports.printTicket.rejected, state => {
+            state.loading = 'idle';
+        })
+            .addCase(exports.updateTicket.fulfilled, state => {
+            state.loading = 'idle';
+        })
+            .addCase(exports.updateTicket.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(exports.updateTicket.rejected, state => {
+            state.loading = 'idle';
+        })
+            .addCase(exports.printTickets.fulfilled, state => {
+            state.loading = 'idle';
+        })
+            .addCase(exports.printTickets.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(exports.printTickets.rejected, state => {
+            state.loading = 'idle';
+        })
+            .addCase(exports.updateOrderPrep.fulfilled, state => {
+            state.loading = 'idle';
+        })
+            .addCase(exports.updateOrderPrep.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(exports.updateOrderPrep.rejected, state => {
+            state.loading = 'idle';
+        })
+            .addCase(exports.printReceipt.fulfilled, state => {
+            state.loading = 'idle';
+        })
+            .addCase(exports.printReceipt.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(exports.printReceipt.rejected, state => {
+            state.loading = 'idle';
+        });
+    }
+});
+_a = ordersSlice.actions, exports.resetOrders = _a.resetOrders, exports.setCurrentOrder = _a.setCurrentOrder, exports.skipFetchOrders = _a.skipFetchOrders, exports.updateOrder = _a.updateOrder;
+const selectOrders = (state) => {
+    const { entities: orders, loading, error } = state.orders;
+    return { orders, loading, error };
+};
+exports.selectOrders = selectOrders;
+const selectCurrentOrder = (state) => {
+    return state.orders.currentOrder;
+};
+exports.selectCurrentOrder = selectCurrentOrder;
+const selectCurrentOrders = (state) => {
+    const { entities, loading, error } = state.orders;
+    const orders = entities.filter(i => {
+        const tz = utils_1.timezoneMap[i.timezone];
+        const fireDate = (0, utils_1.isoToDate)(i.fire_at, tz);
+        const currentDate = (0, utils_1.currentLocalDate)(tz);
+        return (0, utils_1.notDone)(i.prep_status) && fireDate < currentDate;
+    });
+    return { orders, loading, error };
+};
+exports.selectCurrentOrders = selectCurrentOrders;
+const selectFutureOrders = (state) => {
+    const { entities, loading, error } = state.orders;
+    const orders = entities.filter(i => {
+        const tz = utils_1.timezoneMap[i.timezone];
+        const fireDate = (0, utils_1.isoToDate)(i.fire_at, tz);
+        const currentDate = (0, utils_1.currentLocalDate)(tz);
+        return (0, utils_1.notDone)(i.prep_status) && fireDate > currentDate;
+    });
+    return { orders, loading, error };
+};
+exports.selectFutureOrders = selectFutureOrders;
+const selectOrdersCounts = (state) => {
+    const { current, future, qa } = state.orders.counts;
+    return { current, future, qa };
+};
+exports.selectOrdersCounts = selectOrdersCounts;
+exports.ordersReducer = ordersSlice.reducer;

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

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resetPasswordReducer = exports.selectResetPassword = exports.resetPasswordReset = exports.resetPassword = exports.sendPasswordResetEmail = exports.ResetPasswordActionType = 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,
+    resetSent: false
+};
+var ResetPasswordActionType;
+(function (ResetPasswordActionType) {
+    ResetPasswordActionType["SendPasswordResetEmail"] = "resetPassword/sendPasswordResetEmail";
+    ResetPasswordActionType["ResetPassword"] = "resetPassword/resetPassword";
+})(ResetPasswordActionType = exports.ResetPasswordActionType || (exports.ResetPasswordActionType = {}));
+exports.sendPasswordResetEmail = (0, toolkit_1.createAsyncThunk)(ResetPasswordActionType.SendPasswordResetEmail, (requestData, { getState, rejectWithValue }) => tslib_1.__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 = (0, utils_1.makeFormErrors)(err);
+        return rejectWithValue(errors);
+    }
+}));
+exports.resetPassword = (0, toolkit_1.createAsyncThunk)(ResetPasswordActionType.ResetPassword, (requestData, { getState, rejectWithValue }) => tslib_1.__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 = (0, utils_1.makeFormErrors)(err);
+        return rejectWithValue(errors);
+    }
+}));
+const resetPasswordSlice = (0, toolkit_1.createSlice)({
+    name: types_1.ReducerType.ResetPassword,
+    initialState,
+    reducers: {
+        resetPasswordReset: () => initialState
+    },
+    extraReducers: builder => {
+        builder
+            .addCase(exports.sendPasswordResetEmail.fulfilled, state => {
+            state.resetSent = true;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(exports.sendPasswordResetEmail.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(exports.sendPasswordResetEmail.rejected, (state, action) => {
+            state.loading = 'idle';
+            state.error = action.payload;
+        })
+            .addCase(exports.resetPassword.fulfilled, state => {
+            state.resetSent = false;
+            state.success = true;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(exports.resetPassword.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(exports.resetPassword.rejected, (state, action) => {
+            state.loading = 'idle';
+            state.error = action.payload;
+        });
+    }
+});
+exports.resetPasswordReset = resetPasswordSlice.actions.resetPasswordReset;
+const selectResetPassword = (state) => state.resetPassword;
+exports.selectResetPassword = selectResetPassword;
+exports.resetPasswordReducer = resetPasswordSlice.reducer;

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

@@ -0,0 +1,95 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.revenueCentersReducer = exports.selectRevenueCenterCount = exports.selectRevenueCenters = exports.setRevenueCenters = exports.resetRevenueCenters = exports.fetchLocations = exports.fetchRevenueCenters = exports.RevenueCentersActionType = 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 = {
+    revenueCenters: [],
+    loading: 'idle',
+    error: null
+};
+var RevenueCentersActionType;
+(function (RevenueCentersActionType) {
+    RevenueCentersActionType["FetchRevenueCenters"] = "revenueCenters/fetchRevenueCenters";
+    RevenueCentersActionType["FetchLocations"] = "revenueCenters/fetchLocations";
+})(RevenueCentersActionType = exports.RevenueCentersActionType || (exports.RevenueCentersActionType = {}));
+exports.fetchRevenueCenters = (0, toolkit_1.createAsyncThunk)(RevenueCentersActionType.FetchRevenueCenters, (requestData, { getState, rejectWithValue }) => tslib_1.__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
+            ? (0, utils_1.addDistance)(data, { lat: requestData.lat, lng: requestData.lng })
+            : data;
+        return revenueCenters;
+    }
+    catch (err) {
+        return rejectWithValue(err);
+    }
+}));
+exports.fetchLocations = (0, toolkit_1.createAsyncThunk)(RevenueCentersActionType.FetchLocations, (requestData, { getState, rejectWithValue }) => tslib_1.__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
+            ? (0, utils_1.addDistance)(data, { lat: requestData.lat, lng: requestData.lng })
+            : data;
+        return revenueCenters;
+    }
+    catch (err) {
+        return rejectWithValue(err);
+    }
+}));
+const revenueCentersSlice = (0, toolkit_1.createSlice)({
+    name: types_1.ReducerType.RevenueCenters,
+    initialState,
+    reducers: {
+        resetRevenueCenters: () => initialState,
+        setRevenueCenters: (state, action) => {
+            state.revenueCenters = action.payload;
+        }
+    },
+    extraReducers: builder => {
+        builder
+            .addCase(exports.fetchRevenueCenters.fulfilled, (state, action) => {
+            state.revenueCenters = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(exports.fetchRevenueCenters.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(exports.fetchRevenueCenters.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        })
+            .addCase(exports.fetchLocations.fulfilled, (state, action) => {
+            state.revenueCenters = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(exports.fetchLocations.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(exports.fetchLocations.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        });
+    }
+});
+_a = revenueCentersSlice.actions, exports.resetRevenueCenters = _a.resetRevenueCenters, exports.setRevenueCenters = _a.setRevenueCenters;
+const selectRevenueCenters = (state) => state.revenueCenters;
+exports.selectRevenueCenters = selectRevenueCenters;
+const selectRevenueCenterCount = (state) => state.revenueCenters ? state.revenueCenters.revenueCenters.length : 0;
+exports.selectRevenueCenterCount = selectRevenueCenterCount;
+exports.revenueCentersReducer = revenueCentersSlice.reducer;

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