@feedmepos/mf-order-setting 0.0.4 → 0.0.6

package/src/index.d.ts

@@ -0,0 +1,3 @@
+declare module 'google.maps';
+
+export {};

package/src/main.ts

@@ -0,0 +1,77 @@
+import './assets/main.css'
+
+import { computed, createApp } from 'vue'
+import { createPinia } from 'pinia'
+import Entry from './Entry.vue'
+import { router } from './router'
+import { initialize, useCoreStore } from '@feedmepos/mf-common'
+import { FeedMeUI } from '@feedmepos/ui-library';
+import { AuthApi } from './api/auth'
+import { getAuth, signInWithCustomToken } from 'firebase/auth'
+import { initializeApp } from 'firebase/app'
+import { useIframeStore } from './stores/iframe'
+import { Quasar, Dialog } from 'quasar';
+
+
+const app = createApp(Entry)
+
+app.use(createPinia())
+app.use(router)
+
+
+app.use(Quasar, {
+    plugins: {
+        Dialog,
+    },
+});
+app.use(FeedMeUI);
+const CoreStore = useCoreStore();
+
+const iframeMode = computed(() => {
+    return new URLSearchParams(window.location.search).get('iframe') === 'true';
+});
+
+useIframeStore().init(iframeMode.value);
+
+const firebaseApp = initializeApp({
+    apiKey: import.meta.env.VITE_FIREBASE_API_KEY,
+    authDomain: import.meta.env.VITE_FIREBASE_AUTH_DOMAIN,
+    projectId: import.meta.env.VITE_FIREBASE_PROJECT_ID,
+    storageBucket: import.meta.env.VITE_FIREBASE_STORAGE_BUCKET,
+    messagingSenderId: import.meta.env.VITE_FIREBASE_MESSAGING_SENDER_ID,
+    appId: import.meta.env.VITE_FIREBASE_APP_ID,
+    measurementId: import.meta.env.VITE_FIREBASE_MEASUREMENT_ID,
+    databaseURL: import.meta.env.VITE_FIREBASE_DATABASE_URL,
+});
+
+const firebaseAuth = getAuth(firebaseApp);
+
+async function signInWithToken(token: string) {
+    const customToken = await AuthApi.getCustomToken(token);
+    const { user } = await signInWithCustomToken(firebaseAuth, customToken);
+    await CoreStore.signInWithToken({ ...user, id: user.uid }, await user.getIdToken());
+}
+
+if (iframeMode.value) {
+    router.beforeEach((to, from, next) => {
+        window.addEventListener('message', async (event: MessageEvent<{ event: string, data: any }>) => {
+            switch (event.data.event) {
+                case 'init':
+                    await signInWithToken(event.data.data.token);
+                    await CoreStore.changeCountry(event.data.data.country);
+                    await CoreStore.changeBusiness(event.data.data.business);
+                    CoreStore.changeRestaurant(event.data.data.restaurant);
+                    break;
+                default:
+                    break;
+            }
+        });
+        next();
+    });
+}
+if (!iframeMode.value || import.meta.env.VITE_DEBUG_MODE === 'true') {
+    initialize(import.meta.env.VITE_AUTH_CLIENT_ID);
+    CoreStore.setNamespace(import.meta.env.DEV ? 'dev' : 'prod');
+}
+
+app.mount('#app')

package/src/modules/kiosk/interface.ts

@@ -0,0 +1,16 @@
+import { Printer, ScannerInfoDto, KioskTerminalInfoDto } from '@entity';
+export interface MfKioskDeviceConfigs {
+    printerInfo?: Printer,
+    scannerInfo?: ScannerInfoDto,
+    terminalInfo?: KioskTerminalInfoDto,
+}
+
+export interface MfKioskDevice {
+    name: string,
+    machineId: string,
+    config: MfKioskDeviceConfigs,
+    activatedAt: Date,
+}
+
+
+

package/src/modules/order-setting/interface.ts

@@ -0,0 +1,4 @@
+import type { MfKioskOrderSetting } from './kiosk/interface';
+export interface MfOrderSetting {
+    kiosk: MfKioskOrderSetting
+}

package/src/modules/order-setting/kiosk/interface.ts

@@ -0,0 +1,52 @@
+export interface MfDisplayStandSetting {
+    enabled: boolean,
+    standSlotRange: {
+        min: number,
+        max: number,
+    },
+    prefix: string | null,
+    padDigit: number,
+}
+
+export interface MfKioskPickAtCounterSetting {
+    enabled: boolean,
+}
+
+export interface MfKioskSequenceNumberSetting {
+    prefix: string,
+    current: number,
+}
+
+export interface MfKioskDineInSetting {
+    enabled: boolean,
+    sequenceNumber: MfKioskSequenceNumberSetting,
+    displayStand: MfDisplayStandSetting,
+    pickUp: MfKioskPickAtCounterSetting,
+}
+
+export interface MfKioskTakeawaySetting {
+    enabled: boolean,
+}
+
+export interface MfKioskOrderSetting {
+    dineIn: MfKioskDineInSetting,
+    takeaway: MfKioskTakeawaySetting,
+}
+
+export interface DisplayStandSettingForm {
+    enabled: boolean,
+    standSlotRange: {
+        min: number | null,
+        max: number | null
+    },
+    prefix: string | null,
+    padDigit: number | null,
+}
+
+type KioskPickAtCounterSettingForm = MfKioskPickAtCounterSetting;
+export interface KioskDineInSettingForm {
+    enabled: boolean,
+    sequenceNumber: MfKioskSequenceNumberSetting,
+    displayStand: DisplayStandSettingForm,
+    pickUp: KioskPickAtCounterSettingForm,
+}

package/src/plugins/google-maps.ts

@@ -0,0 +1,28 @@
+// import type { CustomPlugin } from './initializer';
+// import type {  } from 'google.maps';
+// import firebase from 'firebase/app';
+
+// const apiKey = import.meta.env.VITE_GOOGLE_MAP_API_KEY;
+
+// const GoogleMap: CustomPlugin = {
+//   init() {
+//     const script = document.createElement('script');
+//     script.src = `https://maps.googleapis.com/maps/api/js?v=weekly&key=${apiKey}&libraries=places&callback=initMap`;
+//     script.defer = true;
+//     script.async = true;
+//     window.initMap = function() {
+//       // init map function
+//     };
+//     document.head.appendChild(script);
+//   },
+// };
+
+// declare global {
+//   interface Window {
+//     initMap: () => void;
+//     google: typeof google;
+//     recaptchaVerifier: firebase.auth.RecaptchaVerifier;
+//   }
+// }
+
+// export default GoogleMap;

package/src/router/index.ts

@@ -0,0 +1,10 @@
+import { createRouter, createWebHistory } from 'vue-router'
+import { routes } from './routes'
+
+const router = createRouter({
+  history: createWebHistory(),
+  routes,
+})
+
+export { router }
+export default router;

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;
+    },
+  }
+  
+});