meemup-library 1.0.64 → 1.0.65

package/dist/controllers/KitchenController.d.ts

@@ -0,0 +1,21 @@
+import EnumOrderType from "../enums/EnumOrderType";
+import IKitchenScreenSetting from "../interfaces/IKitchenScreenSetting";
+import IKitchenOrderDetail from "../interfaces/IKitchenOrderDetail";
+import IKitchenTimes from "../interfaces/IKitchenTimes";
+import IEmergencyBrake from "../interfaces/IEmergencyBrake";
+import IKitchenZone from "../interfaces/IKitchenZone";
+import IKitchenOrderDetailItems from "../interfaces/IKitchenOrderDetailItems";
+declare const _default: {
+    atLeastOneItemToShowInKitchen(list: IKitchenOrderDetailItems[]): boolean;
+    filterOrderDetailReducer(orders: IKitchenOrderDetail[], setting: IKitchenScreenSetting): IKitchenOrderDetail[];
+    forToday(desiredDate: string): boolean;
+    convertStrToSecond(str?: string | null): number;
+    dateToSecond(date: Date): number;
+    calculateTik(detail: IKitchenOrderDetail, times: IKitchenTimes, emergency: IEmergencyBrake, zones: IKitchenZone[]): number;
+    sortOrders(orders: IKitchenOrderDetail[], setting: IKitchenScreenSetting): IKitchenOrderDetail[];
+    listToMatrix(setting: IKitchenScreenSetting, orders: IKitchenOrderDetail[], page: number): IKitchenOrderDetail[][];
+    calculateTotalPage(listLength: number, pageSize: number): number;
+    getOrderTypeColor(orderType: EnumOrderType, setting: IKitchenScreenSetting): string;
+    getOrderTypeLabel(orderType: EnumOrderType): "" | "Delivery" | "Dining" | "Pickup";
+};
+export default _default;

package/dist/controllers/KitchenController.js

@@ -0,0 +1,149 @@
+import EnumOrderType from "../enums/EnumOrderType";
+import EnumKitchenScreenSortOrders from "../enums/EnumKitchenScreenSortOrders";
+import { initKitchenOrderDetail } from "../interfaces/IKitchenOrderDetail";
+export default new class KitchenController {
+    atLeastOneItemToShowInKitchen(list) {
+        let result = false;
+        list.forEach(value => {
+            if (value.displayOnKitchenDisplay)
+                result = true;
+        });
+        return result;
+    }
+    filterOrderDetailReducer(orders, setting) {
+        orders = orders.filter(i => setting.showOrdersViaStatus.includes(i.state));
+        orders = orders.filter(i => i.desiredDateTime === null || i.desiredDateTime === "" || this.forToday(i.desiredDateTime));
+        orders = orders.filter(i => i.displayOnKitchenDisplay && this.atLeastOneItemToShowInKitchen(i.items));
+        return this.sortOrders(orders.filter(i => i.id !== initKitchenOrderDetail.id), setting);
+    }
+    forToday(desiredDate) {
+        try {
+            let dd = new Date();
+            let des = new Date(desiredDate);
+            return dd.getFullYear() === des.getFullYear() && dd.getMonth() === des.getMonth() && dd.getDate() === des.getDate();
+        }
+        catch (_a) {
+            return true;
+        }
+    }
+    convertStrToSecond(str = "00:00:00") {
+        if (str === null)
+            return 0;
+        let second = 0;
+        let minute = 0;
+        let hour = 0;
+        let parts = str.split(":").reverse();
+        if (parts.length > 0)
+            second = +parts[0];
+        if (parts.length > 1)
+            minute = +parts[1];
+        if (parts.length > 2)
+            hour = +parts[2];
+        return (hour * 60 * 60) + (minute * 60) + second;
+    }
+    dateToSecond(date) {
+        return parseInt((date.getTime() / 1000) + "");
+    }
+    calculateTik(detail, times, emergency, zones) {
+        // console.log(`desired date time : ${new Date(detail.desiredDateTime)}`)
+        // console.log(`current date time : ${new Date()}`)
+        const { deliveryMinimumTime, minimumPreparationTime, pickupMinimumTime, diningMinimumTime } = times;
+        const { deliveryDelayTime, pickupDelayTime } = emergency;
+        let des = this.dateToSecond(new Date(detail.desiredDateTime));
+        let cur = this.dateToSecond(new Date());
+        let deliveryTime = 0;
+        let pre = this.convertStrToSecond(detail.preparationTime);
+        switch (detail.type) {
+            case EnumOrderType.delivery:
+                //append delivery delay time
+                des += (deliveryDelayTime * 60);
+                deliveryTime = (deliveryMinimumTime * 60);
+                let zone = zones.find(i => i.id === detail.zoneId);
+                if (zone)
+                    deliveryTime += (zone === null || zone === void 0 ? void 0 : zone.additionalDeliveryTime) * 60;
+                des += deliveryTime;
+                break;
+            case EnumOrderType.pickup:
+                //append delivery delay time
+                des += (pickupDelayTime * 60);
+                des += (pickupMinimumTime * 60);
+                break;
+            case EnumOrderType.dining:
+                des += (diningMinimumTime * 60);
+                break;
+            default:
+                break;
+        }
+        des += (minimumPreparationTime * 60);
+        des += pre;
+        des -= cur;
+        if (des > 0)
+            return des;
+        return 0;
+    }
+    sortOrders(orders, setting) {
+        switch (setting.sortOrders) {
+            case EnumKitchenScreenSortOrders.ORDER_NUMBER:
+                return orders.sort((a, b) => a.number > b.number ? -1 : 1);
+            case EnumKitchenScreenSortOrders.REGISTRATION_TIME:
+                return orders.sort((a, b) => a.registrationDate > b.registrationDate ? -1 : 1);
+            case EnumKitchenScreenSortOrders.DESIRED_TIME:
+                return orders.sort((a, b) => a.desiredDateTime > b.desiredDateTime ? 1 : -1);
+            case EnumKitchenScreenSortOrders.PREPARATION_TIME:
+                return orders.sort((a, b) => a.preparationTime > b.preparationTime ? 1 : -1);
+            default:
+                return orders;
+        }
+    }
+    listToMatrix(setting, orders, page) {
+        let matrix = [];
+        let i;
+        let k;
+        const pageSize = setting.row * setting.column;
+        let start = (page - 1) * pageSize;
+        let stop = page * pageSize;
+        let list = this.sortOrders(orders, setting).slice(start, stop);
+        for (i = 0, k = -1; i < list.length; i++) {
+            if (i % setting.column === 0) {
+                k++;
+                matrix.push([]);
+            }
+            matrix[k].push(list[i]);
+        }
+        matrix.forEach(value => {
+            while (value.length < setting.column) {
+                value.push(initKitchenOrderDetail);
+            }
+        });
+        return matrix;
+    }
+    calculateTotalPage(listLength, pageSize) {
+        let part1 = parseInt((listLength / pageSize) + "");
+        let part2 = listLength % pageSize === 0 ? 0 : 1;
+        return part1 + part2 === 0 ? 1 : part1 + part2;
+    }
+    getOrderTypeColor(orderType, setting) {
+        switch (orderType) {
+            case EnumOrderType.delivery:
+                return setting.deliveryColor;
+            case EnumOrderType.dining:
+                return setting.diningColor;
+            case EnumOrderType.pickup:
+                return setting.pickupColor;
+            default:
+                return "#000";
+        }
+    }
+    getOrderTypeLabel(orderType) {
+        switch (orderType) {
+            case EnumOrderType.delivery:
+                return "Delivery";
+            case EnumOrderType.dining:
+                return "Dining";
+            case EnumOrderType.pickup:
+                return "Pickup";
+            default:
+                return "";
+        }
+    }
+}();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "meemup-library",
-  "version": "1.0.64",
+  "version": "1.0.65",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",