@feedmepos/mf-order-setting 0.0.2 → 0.0.6

package/src/router/routes.ts

@@ -0,0 +1,43 @@
+import { type RouteRecordRaw } from 'vue-router'
+import KioskDevicesView from '@/views/kiosk/devices/KioskDevicesView.vue';
+import KioskSettingView from '@/views/kiosk/settings/KioskSettingView.vue';
+import { PortalRoute } from '@/utils/constants/route';
+import KioskView from '@/views/kiosk/KioskView.vue';
+import OrderSettingsView from '@/views/order-settings/OrderSettingsView.vue';
+import FeedMeExpress from '../views/feedme-express/FeedMeExpress.vue';
+import Orders from '@/views/all-orders/Orders.vue';
+
+const routes: RouteRecordRaw[] = [
+  {
+    path: PortalRoute.KioskRoute,
+    name: 'Kiosk',
+    component: KioskView,
+  },
+  {
+    path: PortalRoute.KioskDeviceRoute,
+    name: 'Kiosk Device',
+    component: KioskDevicesView
+  },
+  {
+    path: PortalRoute.KioskOrderSettingRoute,
+    name: 'Kiosk Order Setting',
+    component: KioskSettingView
+  },
+  {
+    path: PortalRoute.OrderSettingView,
+    name: 'Order Setting View',
+    component: OrderSettingsView
+  },
+  {
+    path: PortalRoute.FeedMeExpressView,
+    name: 'FeedMe Express',
+    component: FeedMeExpress
+  },
+  {
+    path: PortalRoute.AllOrdersView,
+    name: 'All Orders',
+    component: Orders
+  }
+];
+
+export { routes }

package/src/stores/app/index.ts

@@ -0,0 +1,58 @@
+import { initialize } from '@feedmepos/menu';
+
+import { defineStore } from 'pinia';
+
+import { FdoCountry, F_COUNTRY, FdoPublicSetting } from '@feedmepos/core/entity';
+import { Country, Config, FeatureFlag } from '@feedmepos/core';
+import { defaultCountry } from '@/api';
+import { publicSettingApi } from '@/api/public-setting';
+
+
+interface AppState {
+  country: FdoCountry;
+  publicSetting: FdoPublicSetting;
+}
+
+
+function initAppState(): AppState {
+  return {
+    country: Country.getCountry(defaultCountry) as FdoCountry,
+    publicSetting: {
+      delivery: {
+        feedMe: {
+          areas: [],
+          enable: false,
+          maxDistance: 0,
+        },
+      },
+      sms: {
+        firebase: false,
+      },
+      assets: {
+        groups: [],
+      },
+      aiSettings: {
+        remy: { enable: false, }
+      }
+    } as FdoPublicSetting
+  };
+}
+
+export const useAppStore = defineStore('app', {
+  state: () => {
+    return initAppState();
+  },
+  actions: {
+    async getPublicSetting() {
+      this.publicSetting = await publicSettingApi.read();
+      return this.publicSetting;
+    },
+    async updatePublicSetting(setting: Partial<FdoPublicSetting>) {
+      this.publicSetting = await publicSettingApi.update({
+        ...this.publicSetting,
+        ...setting
+      });
+      return this.publicSetting;
+    }
+  },
+});

package/src/stores/iframe/index.ts

@@ -0,0 +1,23 @@
+import { defineStore } from "pinia";
+import { computed } from "vue";
+
+interface State {
+    isIframe: boolean;
+}
+
+export const useIframeStore = defineStore('iframe', () => {
+    const _state: State = {
+        isIframe: false
+    }
+
+    const state = computed(() => _state);
+
+    function init(isIframe: boolean){
+        _state.isIframe = isIframe;
+    }
+
+    return {
+        state,
+        init
+    }
+});

package/src/stores/kiosk/index.ts

@@ -0,0 +1,40 @@
+import { defineStore } from "pinia";
+import { KioskApi } from "@/api/kiosk";
+import { ref } from 'vue';
+import { type MfKioskDevice } from "../../modules/kiosk/interface";
+import { KioskMapper } from "./mapper";
+
+interface State {
+    otp : string;
+    devices: MfKioskDevice[];
+}
+
+export const useKioskStore = defineStore('kiosk', () => {
+
+    const state = ref<State>({
+        otp: '',
+        devices: [],
+    });
+
+    async function requestOtp(){
+        const result = await KioskApi.requestOtp();
+        state.value.otp = result.otp;
+    }
+
+    async function getDevices(){
+        const result = await KioskApi.getDevices();
+        state.value.devices = result.map((r) => KioskMapper.toMfKioskDevice(r));
+    }
+
+    async function unbind(machineId: string){
+        await KioskApi.unbind(machineId);
+        await getDevices();
+    }
+
+    return {
+        state,
+        requestOtp,
+        getDevices,
+        unbind,
+    }
+});

package/src/stores/kiosk/mapper.ts

@@ -0,0 +1,25 @@
+import { type MfKioskDevice } from "@/modules/kiosk/interface";
+import type { KioskDeviceDto } from "@entity";
+
+const toMfKioskDevice = (dto : KioskDeviceDto) : MfKioskDevice => {
+    return {
+        name: dto.name ?? 'N/A',
+        machineId: dto.machineId,
+        config: {
+            scannerInfo: dto.scannerInfo ?? undefined,
+            printerInfo: dto.printerInfo ?? undefined,
+            terminalInfo: dto.terminalInfo ?? undefined,
+        },
+        activatedAt: tokenToActivatedAt(dto.token),
+    };
+};
+
+function tokenToActivatedAt(token: string): Date {
+    const decoded = token.substring(0, 8);
+    const timestamp = parseInt(decoded, 16);
+    return new Date(timestamp * 1000);
+}
+
+export const KioskMapper = {
+    toMfKioskDevice,
+}

package/src/stores/menu/menu.ts

@@ -0,0 +1,258 @@
+import { generator, overrideMenu } from '@feedmepos/menu';
+import { F_MENU_VERSION, FdoHasPosition, FdoItemOverriderV4, FdoItemVariant, FdoMenuV4, FdoMenuV4Catalog, FdoMenuV4Category, FdoMenuV4Item, FdoMenuV4VariantGroup, FdtoRestaurantWithMenuV4 } from '@feedmepos/menu/entity';
+
+import { defineStore } from 'pinia';
+import { menuApi } from '@/api/menu';
+import { sort } from '@/helpers/iteration';
+import type { BaseRules, MenuRules } from '../type';
+import { mapVariant, type CategorizedItem } from '@/helpers/menu';
+import { useCoreStore } from '@feedmepos/mf-common';
+
+interface MenuState {
+  restaurants: FdtoRestaurantWithMenuV4[];
+  menu: { _rev: string } & FdoMenuV4;
+  currentCatalogId: string | null;
+  currentSchedulerId: string;
+}
+
+function initMenuState(): MenuState {
+  return {
+    restaurants: [],
+    menu: { ...generator.initMenuV4(), _rev: '' },
+    currentCatalogId: null,
+    currentSchedulerId: '',
+  };
+}
+
+export function sortPosition<T extends FdoHasPosition>(
+  arr: T[],
+  elseIf: keyof T | ((v: T) => string),
+) {
+  const cloned = arr;
+  const result = cloned.reduce<{ hasPosition: T[], noPosition: T[] }>((pv, v) => {
+    if (v.position == null) {
+      pv.noPosition.push(v);
+    } else {
+      pv.hasPosition.push(v);
+    }
+
+    return pv;
+  }, { hasPosition: [], noPosition: [] });
+
+  return [
+    ...result.hasPosition.sort((a, b) => (a.position as number) - (b.position as number)),
+    ...sort(result.noPosition, { selector: elseIf }),
+  ];
+}
+type Item = Omit<FdoMenuV4Item, 'variant'> & {
+  codeName: string;
+  variant?: Omit<FdoItemVariant, 'variantCombinations'> & {
+    variantCombinations: (VariantItem & { codeName: string })[]
+  }
+};
+
+interface VariantItem extends FdoItemOverriderV4 {
+  codeName: string;
+}
+
+
+export function categorizedItems(
+  categories: (Omit<FdoMenuV4Category, '_id'> & { _id: string | null })[],
+  items: FdoMenuV4Item[],
+): CategorizedItem[] {
+  const mapped = items.reduce<{ [key: string]: Item[] }>((pv, p) => {
+    const key = p.category || '';
+    const combinations = mapVariant(p.variant?.variantGroupIds);
+    const i = {
+      ...p,
+      codeName: [p.code, p.name].filter(v => !!v).join(' '),
+      variant: {
+        variantGroupIds: p.variant?.variantGroupIds || [],
+        variantCombinations: (p.variant?.variantCombinations || []).map(vc => {
+          const code = vc.code;
+          const name = vc.name || combinations[vc.combinationKey || ''];
+          return {
+            ...vc,
+            codeName: [code, name].filter(v => !!v).join(' ').trim() || '-',
+          };
+        })
+      },
+    };
+    pv[key] = !pv[key] ? [i] : [...pv[key], i];
+    return pv;
+  }, {});
+
+  return categories.map((category) => {
+    return {
+      id: category._id,
+      name: category.name,
+      items: mapped[category._id || ''] || [],
+    };
+  });
+}
+
+export const useMenuStore = defineStore('menu', {
+  state: () => {
+    return initMenuState();
+  },
+  getters: {
+    version() {
+      return (useCoreStore().currentBusiness?.value?.menuVersion || F_MENU_VERSION.enum.v3) as F_MENU_VERSION;
+    },
+   
+    mergedMenu(): FdoMenuV4 {
+      const res = overrideMenu({
+        menu: this.menu as FdoMenuV4,
+        catalogId: this.currentCatalogId,
+        
+      });
+
+      
+      return res;
+
+    },
+    catalogs(): FdoMenuV4Catalog[] {
+      const catalogs = this.mergedMenu.modules.catalog;
+      return catalogs
+    },
+    currentCatalog: (state): FdoMenuV4Catalog | undefined => {
+      return state.menu.modules.catalog.find(
+        (catalog) => catalog._id === state.currentCatalogId
+      );
+    },
+
+    catalogOptions(): { label: string; value: string | null }[] {
+      return [
+        {
+          label: 'Main',
+          value: null,
+        },
+        ...this.catalogs.map((catalog) => ({
+          label: catalog.name,
+          value: catalog._id,
+        })),
+      ];
+    },
+    categories(): (Omit<FdoMenuV4Category, '_id'> & { _id: string | null })[] {
+      const categories = this.mergedMenu.modules.category;
+      return [
+        ...this.rules.item.addon ? [{ _id: this.currentCatalogId ? '' : null, name: 'Addon', position: 0 }] : [],
+        ...sortPosition(categories, (category) => category.name)
+      ];
+    },
+    items(): FdoMenuV4Item[] {
+      const items = this.mergedMenu.modules.item;
+      return sortPosition(items, (item) => item.code || item.name);
+    },
+    sortedItems(): { [key: string]: number } {
+      const category = this.menu.modules.category;
+      const sorted = sortPosition(category, (c) => c.name)
+        .reduce<{ [key: string]: number }>((pv, c, index) => {
+          pv[c._id] = index;
+          return pv;
+        }, { ['']: 0 });
+
+      const items = this.menu.modules.item;
+      return sortPosition(items, (item) => item.code || item.name)
+        .reduce<{ [key: string]: number }>((pv, item, index) => {
+          pv[item._id] = index + sorted[item.category || ''];
+          return pv;
+        }, {});
+
+    },
+    variants(): FdoMenuV4VariantGroup[] {
+      const variants = this.mergedMenu.modules.variant;
+      return sort(variants, { selector: 'name' });
+    },
+    categorizedItems(): CategorizedItem[] {
+      return categorizedItems(this.categories, this.items);
+    },
+    rules(): MenuRules {
+      const isDefault = this.currentCatalogId == undefined;
+      const isV4 = this.version === F_MENU_VERSION.enum.v4;
+      const noSchedule = this.currentSchedulerId === '';
+      const baseRules: BaseRules = {
+        create: isDefault && noSchedule,
+        edit: isDefault && noSchedule,
+        delete: isDefault && noSchedule,
+      };
+      const allItems = this.items.map(v => v._id);
+      const markupIds = this.currentCatalog?.markupOptions?.reduce<string[]>((pv, opt) => {
+        pv = pv.concat(opt.includeItems == null ? allItems : opt.includeItems.map(v => v._id));
+        return pv;
+      }, []);
+
+      return {
+        item: {
+          ...baseRules,
+          edit: isV4 || noSchedule,
+          sort: isV4 && isDefault && noSchedule,
+          addon: isV4,
+          code: noSchedule,
+          name: isDefault && noSchedule,
+          description: isDefault && noSchedule,
+          category: (isV4 || isDefault) && noSchedule,
+          thumbnail: isDefault && noSchedule,
+          orderFrom: (isV4 || isDefault) && noSchedule,
+          orderFromNone: isDefault,
+          orderFromActiveOnly: !isV4,
+          openPrice: isDefault && noSchedule,
+          unit: isDefault && noSchedule,
+          price: isDefault,
+          editPrice: isDefault,
+          minPrice: isV4 && noSchedule,
+          costing: isV4 && isDefault && noSchedule,
+          tax: isDefault && noSchedule,
+          variant: isDefault && noSchedule,
+          maxVariant: !isV4 ? 2 : 4,
+          group: isDefault && noSchedule,
+          overrideProductGroup: isV4 && noSchedule,
+          inventory: (isV4 || isDefault) && noSchedule,
+          bindToVariant: isV4,
+          print: isDefault && noSchedule,
+          toRoot: isV4 && noSchedule,
+          takeaway: (category) => !!category && (isV4 || isDefault) && noSchedule,
+          multiScheduler: isV4,
+          canRearrange: isV4,
+          sequentialKds: isV4,
+        },
+        category: {
+          ...baseRules,
+          sort: isDefault,
+        },
+        group: {
+          ...baseRules,
+          edit: isV4 || noSchedule,
+          sort: isDefault,
+          applyProduct: isDefault,
+          showAppliedProduct: noSchedule,
+          type: !isV4,
+          insertRawItems: !isV4
+        },
+        scheduler: {
+          override: isV4,
+        },
+        takeaway: {
+          ...baseRules,
+          edit: (isV4 || isDefault) && noSchedule,
+          name: isDefault,
+        },
+        catalog: {
+          name: !isDefault,
+          defaultOrderFrom: isV4,
+          markup: isV4,
+        }
+      };
+    }
+  },
+  actions: {
+    async readMenu() {
+      this.menu = await menuApi.readMenu();
+      this.selectCatalog(null);
+    },
+    selectCatalog(id: string | null) {
+      this.currentCatalogId = id;
+    },
+  }
+  
+});

package/src/stores/order-setting/index.ts

@@ -0,0 +1,61 @@
+import { defineStore } from 'pinia';
+import { OrderSettingApi } from '@/api/order-setting';
+import type { MfKioskDineInSetting, MfKioskOrderSetting, MfKioskTakeawaySetting } from '@/modules/order-setting/kiosk/interface'
+import { OrderSettingMapper } from './mapper';
+import { ref } from 'vue';
+import { OrderSettingsDto, OrderSettingUpdateDto } from '@entity';
+
+
+interface State {
+    kiosk?: MfKioskOrderSetting,
+    orderSetting?: OrderSettingsDto,
+}
+
+export const useOrderSettings = defineStore('orderSetting', () => {
+    const state = ref<State>({});
+
+    async function getSetting(): Promise<void> {
+        const result = await OrderSettingApi.getOrderSetting();
+        setStateFromDto(result);
+    }
+
+    // TODO: refactor while all order settings logic move here
+    async function updateKioskSetting() {
+        if(state.value.orderSetting && state.value.kiosk){
+            const {_id, ...updateDto} = state.value.orderSetting;
+            const kioskUpdate = OrderSettingMapper.toOrderKioskSettingsDto(state.value.kiosk);
+            // ^ sequence number will not updated from portal
+            const update : OrderSettingUpdateDto = {
+                ...updateDto,
+                kioskSettings: kioskUpdate.kioskSettings,
+            }
+            const result = await OrderSettingApi.updateOrderSetting(update);
+            setStateFromDto(result);
+        }
+    }
+
+    function setStateFromDto(dto: OrderSettingsDto){
+        state.value.orderSetting = dto;
+        state.value.kiosk = OrderSettingMapper.convertOrderSettingDto(dto).kiosk;
+    }
+
+    function setKioskDineInSetting(dineInSetting :MfKioskDineInSetting){
+        if(state.value.kiosk){
+            state.value.kiosk.dineIn = dineInSetting;
+        }
+    }
+
+    function setKioskTakeawaySetting(takeawaySetting : MfKioskTakeawaySetting){
+        if(state.value.kiosk){
+            state.value.kiosk.takeaway = takeawaySetting;
+        }
+    }
+
+    return {
+        state,
+        getSetting,
+        updateKioskSetting,
+        setKioskDineInSetting,
+        setKioskTakeawaySetting,
+    };
+});

package/src/stores/order-setting/mapper.ts

@@ -0,0 +1,104 @@
+import { OrderSettingsDto, OrderKioskSettings, OrderKioskDineIn, OrderKioskDineInSequenceDto } from "@entity";
+import type { MfKioskOrderSetting, MfKioskDineInSetting } from '@/modules/order-setting/kiosk/interface';
+import type { MfOrderSetting } from "@/modules/order-setting/interface";
+
+export const defaultDisplayStand = {
+    enabled: false,
+    prefix: null,
+    padDigit: 0,
+    standSlotRange: {
+        min: 1,
+        max: 10,
+    },
+}
+
+export const defaultPickUp = {
+    enabled: false,
+}
+
+const convertOrderSettingDto = (dto: OrderSettingsDto): MfOrderSetting => {
+    return {
+        kiosk: toKiosk(dto.kioskSettings, dto.sequenceSettings?.kioskDineIn),
+    };
+}
+
+const toKiosk = (kioskOrderSettings: OrderKioskSettings, kioskDineInSeq?: OrderKioskDineInSequenceDto): MfKioskOrderSetting => {
+    return {
+        dineIn: toKioskDineInSetting(kioskDineInSeq ?? {
+            current: 0,
+            prefix: '#K',
+        }, kioskOrderSettings.dineIn ?? undefined),
+        takeaway: {
+            enabled: kioskOrderSettings?.canTakeaway ?? false
+        }
+    }
+}
+
+const toKioskDineInSetting = (kioskDineInSeq: OrderKioskDineInSequenceDto, kioskDineInSetting?: OrderKioskDineIn): MfKioskDineInSetting => {
+    if (kioskDineInSetting) {
+        const enabled = true;
+        const displayStand = kioskDineInSetting.displayStand;
+        const pickUp = kioskDineInSetting.pickUp ?? defaultPickUp;
+        return {
+            enabled,
+            sequenceNumber: kioskDineInSeq,
+            pickUp,
+            displayStand: displayStand ? {
+                enabled: true,
+                standSlotRange: displayStand.standSlotRange,
+                prefix: displayStand.prefix,
+                padDigit: displayStand.padDigit,
+            } : defaultDisplayStand,
+        };
+    } else {
+        return {
+            enabled: false,
+            sequenceNumber: kioskDineInSeq,
+            displayStand: defaultDisplayStand,
+            pickUp: defaultPickUp,
+        }
+    }
+}
+const toOrderKioskSettingsDto = (kioskSetting: MfKioskOrderSetting): {
+    kioskSettings: OrderKioskSettings,
+    kioskDineIn?: OrderKioskDineInSequenceDto
+} => {
+    const toOrderKioskDineIn = (dineInSetting: MfKioskDineInSetting): { dineIn: OrderKioskDineIn, kioskDineIn?: OrderKioskDineInSequenceDto } | undefined => {
+        if (dineInSetting.enabled) {
+            return {
+                dineIn: {
+                    requiredSlot: !!dineInSetting.displayStand,
+                    displayStand: dineInSetting.displayStand,
+                    pickUp: dineInSetting.pickUp,
+                },
+                kioskDineIn: dineInSetting.sequenceNumber,
+            }
+        } else {
+            return undefined;
+        }
+    }
+    const orderKioskDineIn = toOrderKioskDineIn(kioskSetting.dineIn);
+    if (orderKioskDineIn) {
+        const { dineIn, kioskDineIn } = orderKioskDineIn;
+        return {
+            kioskSettings: {
+                canTakeaway: kioskSetting.takeaway.enabled,
+                dineIn,
+            },
+            kioskDineIn,
+        }
+    } else {
+        return {
+            kioskSettings: {
+                canTakeaway: kioskSetting.takeaway.enabled,
+            }
+        };
+    }
+}
+
+
+
+export const OrderSettingMapper = {
+    convertOrderSettingDto,
+    toOrderKioskSettingsDto,
+};