@open-tender/store 0.2.16 → 0.3.0

package/dist/esm/slices/kds.js

@@ -1,21 +1,229 @@
 var _a;
-import { createSlice } from '@reduxjs/toolkit';
+import { __assign, __awaiter, __generator } from "tslib";
+import { createAsyncThunk, createSlice } from '@reduxjs/toolkit';
 import { ReducerType } from './types';
+import { currentLocalDate, isoToDate, makeFetchOrdersArgs, makeKdsCounts, makeKdsOrders, notDone, timezoneMap } from '../utils';
+import { addAlert } from './alerts';
 var initialState = {
-    summary: true,
-    page: null,
+    itemTypes: null,
+    columns: 4,
+    boxes: 8,
+    cardWidth: 300,
+    fontSize: 'medium',
     view: null,
-    order: null,
+    page: null,
+    search: null,
     businessDate: null,
-    alarm: true
+    summary: true,
+    orders: [],
+    loading: 'idle',
+    error: null,
+    order: null,
+    counts: { current: null, future: null, qa: null }
 };
+export var KdsActionType;
+(function (KdsActionType) {
+    KdsActionType["FetchKdsOrders"] = "kds/fetchKdsOrders";
+    KdsActionType["UpdateOrder"] = "kds/updateOrder";
+    KdsActionType["PrintTickets"] = "kds/printTickets";
+    KdsActionType["ResetTickets"] = "kds/resetTickets";
+    KdsActionType["PrintReceipt"] = "kds/printReceipt";
+    KdsActionType["PrintTicket"] = "kds/printTicket";
+    KdsActionType["UpdateTicket"] = "kds/updateTicket";
+})(KdsActionType || (KdsActionType = {}));
+export var fetchKdsOrders = createAsyncThunk(KdsActionType.FetchKdsOrders, function (params, _a) {
+    var getState = _a.getState, rejectWithValue = _a.rejectWithValue;
+    return __awaiter(void 0, void 0, void 0, function () {
+        var api, itemTypes, args, orders, ordersKds, counts, err_1;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _b.trys.push([0, 2, , 3]);
+                    api = getState().config.api;
+                    itemTypes = getState().kds.itemTypes;
+                    args = makeFetchOrdersArgs(params);
+                    return [4 /*yield*/, api.getOrders(args)];
+                case 1:
+                    orders = _b.sent();
+                    ordersKds = makeKdsOrders(orders);
+                    counts = makeKdsCounts(itemTypes, ordersKds);
+                    return [2 /*return*/, { orders: orders, counts: counts }];
+                case 2:
+                    err_1 = _b.sent();
+                    return [2 /*return*/, rejectWithValue(err_1)];
+                case 3: return [2 /*return*/];
+            }
+        });
+    });
+});
+export var updateOrder = createAsyncThunk(KdsActionType.UpdateOrder, function (_a, _b) {
+    var orderId = _a.orderId, data = _a.data;
+    var getState = _b.getState, dispatch = _b.dispatch;
+    return __awaiter(void 0, void 0, void 0, function () {
+        var api, order, err_2, detail;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    _c.trys.push([0, 2, , 3]);
+                    api = getState().config.api;
+                    return [4 /*yield*/, api.patchOrder(orderId, data)];
+                case 1:
+                    order = _c.sent();
+                    dispatch(updateKdsOrder(order));
+                    return [3 /*break*/, 3];
+                case 2:
+                    err_2 = _c.sent();
+                    detail = err_2.detail;
+                    dispatch(addAlert(detail));
+                    return [3 /*break*/, 3];
+                case 3: return [2 /*return*/];
+            }
+        });
+    });
+});
+export var printReceipt = createAsyncThunk(KdsActionType.PrintReceipt, function (orderId, _a) {
+    var getState = _a.getState, dispatch = _a.dispatch;
+    return __awaiter(void 0, void 0, void 0, function () {
+        var api, order, err_3, detail;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _b.trys.push([0, 2, , 3]);
+                    api = getState().config.api;
+                    return [4 /*yield*/, api.postReceipt(orderId)];
+                case 1:
+                    order = _b.sent();
+                    dispatch(updateKdsOrder(order));
+                    return [3 /*break*/, 3];
+                case 2:
+                    err_3 = _b.sent();
+                    detail = err_3.detail;
+                    dispatch(addAlert(detail));
+                    return [3 /*break*/, 3];
+                case 3: return [2 /*return*/];
+            }
+        });
+    });
+});
+export var printTickets = createAsyncThunk(KdsActionType.PrintTickets, function (_a, _b) {
+    var orderId = _a.orderId, data = _a.data;
+    var getState = _b.getState, dispatch = _b.dispatch;
+    return __awaiter(void 0, void 0, void 0, function () {
+        var api, order, err_4, detail;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    _c.trys.push([0, 2, , 3]);
+                    api = getState().config.api;
+                    return [4 /*yield*/, api.postTicketsPrint(orderId, data)];
+                case 1:
+                    order = _c.sent();
+                    dispatch(updateKdsOrder(order));
+                    return [3 /*break*/, 3];
+                case 2:
+                    err_4 = _c.sent();
+                    detail = err_4.detail;
+                    dispatch(addAlert(detail));
+                    return [3 /*break*/, 3];
+                case 3: return [2 /*return*/];
+            }
+        });
+    });
+});
+export var resetTickets = createAsyncThunk(KdsActionType.ResetTickets, function (orderId, _a) {
+    var getState = _a.getState, dispatch = _a.dispatch;
+    return __awaiter(void 0, void 0, void 0, function () {
+        var api, order, err_5, detail;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _b.trys.push([0, 2, , 3]);
+                    api = getState().config.api;
+                    return [4 /*yield*/, api.postTicketsReset(orderId)];
+                case 1:
+                    order = _b.sent();
+                    dispatch(updateKdsOrder(order));
+                    return [3 /*break*/, 3];
+                case 2:
+                    err_5 = _b.sent();
+                    detail = err_5.detail;
+                    dispatch(addAlert(detail));
+                    return [3 /*break*/, 3];
+                case 3: return [2 /*return*/];
+            }
+        });
+    });
+});
+export var printTicket = createAsyncThunk(KdsActionType.PrintTicket, function (_a, _b) {
+    var orderId = _a.orderId, ticketNo = _a.ticketNo, status = _a.status;
+    var getState = _b.getState, dispatch = _b.dispatch;
+    return __awaiter(void 0, void 0, void 0, function () {
+        var api, data, order, err_6, detail;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    _c.trys.push([0, 2, , 3]);
+                    api = getState().config.api;
+                    data = status ? { ticket_status: status } : {};
+                    return [4 /*yield*/, api.postTicketPrint(orderId, ticketNo, data)];
+                case 1:
+                    order = _c.sent();
+                    dispatch(updateKdsOrder(order));
+                    return [3 /*break*/, 3];
+                case 2:
+                    err_6 = _c.sent();
+                    detail = err_6.detail;
+                    dispatch(addAlert(detail));
+                    return [3 /*break*/, 3];
+                case 3: return [2 /*return*/];
+            }
+        });
+    });
+});
+export var updateTicket = createAsyncThunk(KdsActionType.UpdateTicket, function (_a, _b) {
+    var orderId = _a.orderId, ticketNo = _a.ticketNo, status = _a.status;
+    var getState = _b.getState, dispatch = _b.dispatch;
+    return __awaiter(void 0, void 0, void 0, function () {
+        var api, order, err_7, detail;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    _c.trys.push([0, 2, , 3]);
+                    api = getState().config.api;
+                    return [4 /*yield*/, api.postTicketStatus(orderId, ticketNo, status)];
+                case 1:
+                    order = _c.sent();
+                    dispatch(updateKdsOrder(order));
+                    return [3 /*break*/, 3];
+                case 2:
+                    err_7 = _c.sent();
+                    detail = err_7.detail;
+                    dispatch(addAlert(detail));
+                    return [3 /*break*/, 3];
+                case 3: return [2 /*return*/];
+            }
+        });
+    });
+});
 export var kdsSlice = createSlice({
     name: ReducerType.Kds,
     initialState: initialState,
     reducers: {
         resetkds: function () { return initialState; },
-        toggleKdsSummary: function (state) {
-            state.summary = !state.summary;
+        setKdsItemTypes: function (state, action) {
+            state.itemTypes = action.payload;
+        },
+        setKdsColumns: function (state, action) {
+            state.columns = action.payload;
+        },
+        setKdsBoxes: function (state, action) {
+            state.boxes = action.payload;
+        },
+        setKdsCardWidth: function (state, action) {
+            state.cardWidth = action.payload;
+        },
+        setKdsFontSize: function (state, action) {
+            state.fontSize = action.payload;
         },
         setKdsPage: function (state, action) {
             state.page = action.payload;
@@ -23,22 +231,142 @@ export var kdsSlice = createSlice({
         setKdsView: function (state, action) {
             state.view = action.payload;
         },
-        setKdsOrder: function (state, action) {
-            state.order = action.payload;
-        },
         setKdsBusinessDate: function (state, action) {
             state.businessDate = action.payload;
         },
-        setKdsAlarm: function (state, action) {
-            state.alarm = action.payload;
+        setKdsSearch: function (state, action) {
+            state.search = action.payload;
+        },
+        toggleKdsSummary: function (state) {
+            state.summary = !state.summary;
+        },
+        setKdsOrder: function (state, action) {
+            state.order = action.payload;
+        },
+        updateKdsOrder: function (state, action) {
+            var updated = action.payload;
+            var tz = timezoneMap[updated.timezone];
+            var updatedOrders = state.orders
+                .map(function (i) {
+                return i.order_uuid === updated.order_uuid ? updated : i;
+            })
+                .filter(function (i) { return i.fire_at; });
+            var orders = updatedOrders
+                .map(function (i) { return (__assign(__assign({}, i), { fireAt: isoToDate(i.fire_at, tz) })); })
+                .sort(function (a, b) { return a.fireAt.getTime() - b.fireAt.getTime(); });
+            var counts = makeKdsCounts(state.itemTypes, orders);
+            var order = state.order ? updated : null;
+            return __assign(__assign({}, state), { orders: orders, order: order, counts: counts });
         }
+    },
+    extraReducers: function (builder) {
+        builder
+            .addCase(fetchKdsOrders.fulfilled, function (state, action) {
+            var _a = action.payload, orders = _a.orders, counts = _a.counts;
+            state.orders = orders;
+            state.counts = counts;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(fetchKdsOrders.pending, function (state) {
+            state.loading = 'pending';
+        })
+            .addCase(fetchKdsOrders.rejected, function (state, action) {
+            state.error = action.payload;
+            state.loading = 'idle';
+        })
+            .addCase(updateOrder.fulfilled, function (state) {
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(updateOrder.pending, function (state) {
+            state.loading = 'pending';
+        })
+            .addCase(updateOrder.rejected, function (state) {
+            state.loading = 'idle';
+        })
+            .addCase(printReceipt.fulfilled, function (state) {
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(printReceipt.pending, function (state) {
+            state.loading = 'pending';
+        })
+            .addCase(printReceipt.rejected, function (state) {
+            state.loading = 'idle';
+        })
+            .addCase(printTickets.fulfilled, function (state) {
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(printTickets.pending, function (state) {
+            state.loading = 'pending';
+        })
+            .addCase(printTickets.rejected, function (state) {
+            state.loading = 'idle';
+        })
+            .addCase(resetTickets.fulfilled, function (state) {
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(resetTickets.pending, function (state) {
+            state.loading = 'pending';
+        })
+            .addCase(resetTickets.rejected, function (state) {
+            state.loading = 'idle';
+        })
+            .addCase(printTicket.fulfilled, function (state) {
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(printTicket.pending, function (state) {
+            state.loading = 'pending';
+        })
+            .addCase(printTicket.rejected, function (state) {
+            state.loading = 'idle';
+        })
+            .addCase(updateTicket.fulfilled, function (state) {
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(updateTicket.pending, function (state) {
+            state.loading = 'pending';
+        })
+            .addCase(updateTicket.rejected, function (state) {
+            state.loading = 'idle';
+        });
     }
 });
-export var resetkds = (_a = kdsSlice.actions, _a.resetkds), toggleKdsSummary = _a.toggleKdsSummary, setKdsPage = _a.setKdsPage, setKdsView = _a.setKdsView, setKdsOrder = _a.setKdsOrder, setKdsBusinessDate = _a.setKdsBusinessDate, setKdsAlarm = _a.setKdsAlarm;
+export var resetkds = (_a = kdsSlice.actions, _a.resetkds), setKdsItemTypes = _a.setKdsItemTypes, setKdsPage = _a.setKdsPage, setKdsView = _a.setKdsView, setKdsBusinessDate = _a.setKdsBusinessDate, setKdsSearch = _a.setKdsSearch, toggleKdsSummary = _a.toggleKdsSummary, setKdsOrder = _a.setKdsOrder, updateKdsOrder = _a.updateKdsOrder;
+export var selectKdsItemTypes = function (state) { return state.kds.itemTypes; };
 export var selectKdsSummary = function (state) { return state.kds.summary; };
 export var selectKdsPage = function (state) { return state.kds.page; };
 export var selectKdsView = function (state) { return state.kds.view; };
-export var selectKdsOrder = function (state) { return state.kds.order; };
 export var selectKdsBusinessDate = function (state) { return state.kds.businessDate; };
-export var selectKdsAlarm = function (state) { return state.kds.alarm; };
+export var selectKdsOrders = function (state) { return state.kds.orders; };
+export var selectKdsOrder = function (state) { return state.kds.order; };
+export var selectKdsCurrentOrders = function (state) {
+    var _a = state.kds, orders = _a.orders, loading = _a.loading, error = _a.error;
+    var filtered = orders.filter(function (i) {
+        var tz = timezoneMap[i.timezone];
+        var fireDate = i.fire_at ? isoToDate(i.fire_at, tz) : null;
+        var currentDate = currentLocalDate(tz);
+        return notDone(i.prep_status) && fireDate && fireDate < currentDate;
+    });
+    return { orders: filtered, loading: loading, error: error };
+};
+export var selectKdsFutureOrders = function (state) {
+    var _a = state.kds, orders = _a.orders, loading = _a.loading, error = _a.error;
+    var filtered = orders.filter(function (i) {
+        var tz = timezoneMap[i.timezone];
+        var fireDate = i.fire_at ? isoToDate(i.fire_at, tz) : null;
+        var currentDate = currentLocalDate(tz);
+        return notDone(i.prep_status) && fireDate && fireDate > currentDate;
+    });
+    return { orders: filtered, loading: loading, error: error };
+};
+export var selectKdsOrdersCounts = function (state) {
+    var _a = state.kds.counts, current = _a.current, future = _a.future, qa = _a.qa;
+    return { current: current, future: future, qa: qa };
+};
 export var kdsReducer = kdsSlice.reducer;

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

@@ -1,4 +1,4 @@
-import { FetchOrdersArgs, ItemTypes, Order, OrderCounts, Orders, OrdersAndCounts, OrderUpdate, RequestError, RequestStatus, TicketStatus, TicketStatusUpdate } from '../types';
+import { FetchOrdersArgs, Orders, RequestError, RequestStatus } from '../types';
 import { AppState } from '../app';
 export interface OrdersState {
     entities: Orders;
@@ -6,73 +6,16 @@ export interface OrdersState {
     error: RequestError;
     current: any;
     refund: any;
-    counts: OrderCounts;
-    itemTypes: ItemTypes | null;
 }
 export declare enum OrdersActionType {
-    FetchOrders = "orders/fetchOrders",
-    RefreshOrders = "orders/refreshOrders",
-    UpdateOrder = "orders/updateOrder",
-    PrintTickets = "orders/printTickets",
-    ResetTickets = "orders/resetTickets",
-    PrintReceipt = "orders/printReceipt",
-    PrintTicket = "orders/printTicket",
-    UpdateTicket = "orders/updateTicket"
+    FetchOrders = "orders/fetchOrders"
 }
-export declare const fetchOrders: import("@reduxjs/toolkit").AsyncThunk<OrdersAndCounts, FetchOrdersArgs, {
+export declare const fetchOrders: import("@reduxjs/toolkit").AsyncThunk<Orders, FetchOrdersArgs, {
     state: AppState;
     rejectValue: RequestError;
 }>;
-export declare const updateOrder: import("@reduxjs/toolkit").AsyncThunk<void, {
-    orderId: string;
-    data: OrderUpdate;
-}, {
-    state: AppState;
-}>;
-export declare const printReceipt: import("@reduxjs/toolkit").AsyncThunk<void, string, {
-    state: AppState;
-}>;
-export declare const printTickets: import("@reduxjs/toolkit").AsyncThunk<void, {
-    orderId: string;
-    data?: OrderUpdate | undefined;
-}, {
-    state: AppState;
-}>;
-export declare const resetTickets: import("@reduxjs/toolkit").AsyncThunk<void, string, {
-    state: AppState;
-}>;
-export declare const printTicket: import("@reduxjs/toolkit").AsyncThunk<void, {
-    orderId: string;
-    ticketNo: number;
-    status?: TicketStatus | undefined;
-}, {
-    state: AppState;
-}>;
-export declare const updateTicket: import("@reduxjs/toolkit").AsyncThunk<void, {
-    orderId: string;
-    ticketNo: number;
-    status: TicketStatusUpdate;
-}, {
-    state: AppState;
-}>;
-export declare const resetOrders: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>, setOrdersItemTypes: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, string>, setOrdersCurrent: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, string>, setOrdersRefund: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, string>, updateOrdersOrder: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, string>;
-export declare const selectItemTypes: (state: AppState) => ItemTypes | null;
+export declare const resetOrders: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>, setOrdersCurrent: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, string>, setOrdersRefund: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, string>;
 export declare const selectOrders: (state: AppState) => OrdersState;
 export declare const selectOrdersCurrent: (state: AppState) => any;
 export declare const selectOrdersRefund: (state: AppState) => any;
-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: Record<string, number> | null;
-    future: Record<string, number> | null;
-    qa: Record<string, number> | null;
-};
 export declare const ordersReducer: import("redux").Reducer<OrdersState, import("redux").AnyAction>;