@feedmepos/mf-order-setting 0.0.2 → 0.0.6

package/src/helpers/iteration.ts

@@ -0,0 +1,87 @@
+import { utils } from '@feedmepos/core';
+const clone = utils.clone;
+
+type Selector<T> = keyof T | ((item: T) => string);
+
+function retrieveValue<T>(element: T, key?: Selector<T>) {
+  if (key === undefined) return element as any;
+  return typeof key === 'function' ? key(element) : `${element[key]}`;
+}
+
+function sort<T>(arr: T[], option?: { selector?: Selector<T>, descending?: boolean } | undefined): T[] {
+  const cloned = clone(arr);
+  return cloned.sort((a, b) => {
+    let keyA = retrieveValue(a, option?.selector);
+    let keyB = retrieveValue(b, option?.selector);
+    if (option?.descending) {
+      const [a, b] = [keyA, keyB];
+      keyA = b;
+      keyB = a;
+    }
+    return keyA.localeCompare(keyB, 'en', { numeric: true, sensitivity: 'base' });
+  });
+}
+
+function group<T>(arr: T[], by: Selector<T>): { [key: string]: T[] } {
+  return arr.reduce<{ [key: string]: T[] }>((pv, v) => {
+    const key = retrieveValue(v, by);
+    pv[key] = [...(pv[key] || []), v];
+    return pv;
+  }, {});
+}
+
+function insertIfNotExist<T>(arr: T[], value: T): T[] {
+  return !arr.includes(value)
+    ? [...arr, value]
+    : arr;
+}
+
+function remove<T>(arr: T[], target: T, selector?: Selector<T>) {
+  return arr.filter((v) => retrieveValue(v, selector) !== retrieveValue(target, selector));
+}
+
+function insertOrUpdate<T>(arr: T[], value: T, selector?: keyof T): T[] {
+  const index = arr.findIndex((el) => retrieveValue(el, selector) === retrieveValue(value, selector));
+  if (index < 0) {
+    return [...arr, value];
+  }
+  return arr.map((oldV, i) => i !== index ? oldV : value);
+}
+
+function insertOrRemove<T>(arr: T[], value: T): T[] {
+  const index = arr.findIndex((el) => el === value);
+  if (index < 0) {
+    return [...arr, value];
+  }
+  return arr.filter((_, i) => i !== index);
+}
+
+function* intersperse(iterable: any[], separator: any) {
+  const iterator = iterable[Symbol.iterator]();
+  const first = iterator.next();
+  if (first.done) return;
+  else yield first.value;
+  for (const value of iterator) {
+    yield separator;
+    yield value;
+  }
+}
+
+function chunk<T>(list: T[], size: number): T[][] {
+  const chunks: T[][] = [];
+  for (let i = 0; i < list.length; i += size) {
+    chunks.push(list.slice(i, i + size > list.length ? list.length : i + size));
+  }
+  return chunks;
+}
+
+export {
+  sort,
+  group,
+  insertIfNotExist,
+  remove,
+  insertOrUpdate,
+  insertOrRemove,
+  intersperse,
+  chunk
+};

package/src/helpers/map.ts

@@ -0,0 +1,92 @@
+import { type MapCoordinate } from '@/components/type';
+
+let googleMap: typeof google;
+
+export function setGoogleMap(map: typeof google) {
+  if (!googleMap) googleMap = map;
+}
+
+const coordinates = Object.freeze({
+  'jb': {
+    lat: 1.492659,
+    lng: 103.7413591
+  },
+});
+
+function coordinateToArray(v: { lat: number; lng: number }) {
+  return [v.lng, v.lat];
+}
+
+function arrayToCoordinate(arr: number[]) {
+  if (arr.length !== 2) throw Error('Invalid coordinate array');
+  return {
+    lat: arr[1],
+    lng: arr[0]
+  };
+}
+
+function generateAreaPaths({
+  center,
+  radius,
+}: {
+  radius: number;
+  center: {
+    lng: number;
+    lat: number;
+  }
+}): { lat: number; lng: number }[] {
+  const searchPoint = [];
+  const radiusLat = (radius / 6371) * (180 / Math.PI);
+  const radiusLng = radiusLat / Math.cos(center.lat * (Math.PI / 180));
+  for (let a = 0; a < 361; a += 45) {
+    const aRad = a * (Math.PI / 180);
+    const x = center.lng + (radiusLng * Math.cos(aRad));
+    const y = center.lat + (radiusLat * Math.sin(aRad));
+    const point = new googleMap.maps.LatLng(y, x, true);
+    searchPoint.push(point);
+  }
+  return searchPoint.map(v => ({ lat: v.lat(), lng: v.lng() }));
+}
+
+function pathToPolygon(path: MapCoordinate[]): number[][] {
+  return path.map((p) => coordinateToArray(p));
+}
+
+function polygonToPath(polygon: number[][]): MapCoordinate[] {
+  return polygon.map((vertex) => arrayToCoordinate(vertex));
+}
+
+function getPolygonCenter(polygon: number[][]): MapCoordinate | undefined {
+  if (!polygon.length) return undefined;
+
+  const { lat, lng } = arrayToCoordinate(polygon[0]);
+  const { maxLng, minLng, maxLat, minLat } = polygon.reduce((pv, path) => {
+    const { lng, lat } = arrayToCoordinate(path);
+    if (lng > pv.maxLng) pv.maxLng = lng;
+    if (lng < pv.minLng) pv.minLng = lng;
+    if (lat > pv.maxLat) pv.maxLat = lat;
+    if (lat < pv.minLat) pv.minLat = lat;
+    return pv;
+  }, {
+    maxLng: lng,
+    minLng: lng,
+    maxLat: lat,
+    minLat: lat
+  });
+
+  return {
+    lng: minLng + ((maxLng - minLng) / 2),
+    lat: minLat + ((maxLat - minLat) / 2),
+  };
+}
+
+export {
+  googleMap,
+  coordinates,
+  coordinateToArray,
+  arrayToCoordinate,
+  generateAreaPaths,
+  pathToPolygon,
+  polygonToPath,
+  getPolygonCenter,
+};

package/src/helpers/menu.ts

@@ -0,0 +1,166 @@
+import { fullVariantCombination } from '@feedmepos/menu';
+import { FdtoGetFallbackPriceReq, FdtoGetFallbackPriceRes, FdoItemOverriderV4, FdoMenuV4Item, FdoItemVariant, F_MENU_MODULE_V4_KEY, F_ORDER_FROM, FdoHasPosition, FdoMenuV4Category, FdoMenuV4VariantGroup, FdoProductTaxSetting, FdtoV4Tax } from '@feedmepos/menu/entity';
+
+import { sort } from './iteration';
+
+import { Country } from '@feedmepos/core';
+import { useMenuStore } from '@/stores/menu/menu';
+import type { CheckboxOption, PickerGroup } from '@/components/type';
+import { useLoading } from '@/composables/loading';
+import { useAppStore } from '@/stores/app';
+import { utils } from '@feedmepos/core';
+const clone = utils.clone;
+
+
+export interface Option {
+  label: string;
+  value: string | null;
+}
+
+// const { minor, checkIsLoading } = useLoading();
+// export const menuLoader = () => ({
+//   updateMenu: async (
+//     req: UpdateMenuModuleRequest | UpdateMenuModuleRequest[],
+//     name: string,
+//     isDelete = false,
+//     performValidate = false,
+//   ) => {
+//     const menuStore = useMenuStore();
+//     const action = isDelete ? 'removed' : 'saved';
+
+//     await minor(
+//       async () => {
+//         await menuStore.updateMenu(req, performValidate);
+//       },
+//       { successMessage: `${name} ${action}`, customId: menuStore.menu._id }
+//     );
+//   },
+//   saveMenuWithThumbnail: async (
+//     data: FdoMenuV4Item, operation: F_OPERATION_TYPE.update | F_OPERATION_TYPE.create, path: string, image?: File | null, performValidate = false) => {
+//     const menuStore = useMenuStore();
+
+//     await minor(
+//       async () => {
+//         let newImageUrl = '';
+//         if (image) {
+//           await firebaseStorage.update(path, image, appApi.imageBucketUrl);
+//           newImageUrl = generateItemThumbnailUrl(path);
+//         }
+
+//         const result = await menuStore.updateMenu({
+//           module: F_MENU_MODULE_V4_KEY.enum.item,
+//           operation: operation,
+//           data: {
+//             ...data,
+//             thumbnail: newImageUrl || data.thumbnail,
+//           },
+//         }, performValidate);
+
+
+//         //handle thumbnail
+//         if (operation === F_OPERATION_TYPE.create && result?.updateId) {
+//           const newPath = result?.updateId ? generateItemThumbnailPath(result.updateId) : generateItemThumbnailPath();
+//           const itemIndex = result?.menu.modules.item.findIndex((item) => item._id === result?.updateId);
+//           const item = menuStore.menu.modules.item[itemIndex];
+//           let newImageUrl = '';
+//           if (image) {
+//             await firebaseStorage.update(newPath, image, appApi.imageBucketUrl);
+//             newImageUrl = generateItemThumbnailUrl(newPath);
+//           }
+//           await menuStore.updateMenu({
+//             module: F_MENU_MODULE_V4_KEY.enum.item,
+//             operation: F_OPERATION_TYPE.update,
+//             data: {
+//               ...item,
+//               _id: result?.updateId,
+//               thumbnail: newImageUrl || data.thumbnail,
+//             },
+//           }, performValidate);
+//         }
+//       },
+//       { successMessage: `${data.name} saved`, customId: menuStore.menu._id }
+//     );
+
+//   },
+//   checkMenuIsLoading: () => checkIsLoading(useMenuStore().menu._id),
+// });
+
+
+type Item = Omit<FdoMenuV4Item, 'variant'> & {
+  codeName: string;
+  variant?: Omit<FdoItemVariant, 'variantCombinations'> & {
+    variantCombinations: (VariantItem & { codeName: string })[]
+  }
+};
+export interface CategorizedItem {
+  id: string | null;
+  name: string;
+  items: Item[];
+}
+
+interface VariantItem extends FdoItemOverriderV4 {
+  codeName: string;
+}
+
+
+export function mapVariant(
+  variantGroupIds: string[] = []
+): { [key: string]: string } {
+  const variants = variantGroupIds.map((id) => useMenuStore().variants.find((v) => v._id === id)).filter((v) => !!v) as FdoMenuV4VariantGroup[];
+  const combinations = fullVariantCombination(variants);
+  return combinations.reduce<{ [key: string]: string }>((pv, c) => {
+    pv[c.combinationKey] = c.selectionName.join(' / ');
+    return pv;
+  }, {});
+}
+
+export function updateBaseItemOverrider(
+  itemId: string,
+  items: FdoItemOverriderV4[],
+  updateFn: (i: FdoItemOverriderV4) => FdoItemOverriderV4,
+): FdoItemOverriderV4[] {
+  const base = items.find((i) => !i.combinationKey) ?? { _id: itemId };
+  const variants = items.filter((i) => !!i.combinationKey);
+  return [updateFn(base), ...variants];
+}
+
+export interface ProductOption extends CheckboxOption {
+  variant?: CheckboxOption[];
+}
+
+export interface Category {
+  id: string;
+  name: string;
+  items: ProductOption[];
+}
+
+
+export type Tax = FdtoV4Tax[] | null | undefined;
+export class ItemTax {
+  static encodeTax(tax: FdoProductTaxSetting) {
+    return `${tax.systemCode}/${tax.taxCode}`;
+  }
+
+  static decodeTax(identifier: string): FdoProductTaxSetting {
+    const [systemCode, taxCode] = identifier.split('/');
+    return { systemCode, taxCode };
+  }
+
+  // static taxSetting() {
+  //   const countryFlattenTaxes = Country.getCountryFlattenTaxes(useAppStore().country.code);
+
+  //   return {
+  //     systemCode: countryFlattenTaxes[0].systemCode,
+  //     countryTaxOptions: countryFlattenTaxes.map((tax) => ({
+  //       label: `${tax.name} (${FdoDecimalToPercentage(tax.rate)}%)`,
+  //       value: ItemTax.encodeTax(tax),
+  //     })),
+  //   };
+  // }
+
+  static getSelectedTax(tax: Tax, fallbackTax: Tax, taxOptions: { label: string, value: string }[]): string | undefined {
+    return (tax ?? fallbackTax ?? [])
+      .map((t) => ItemTax.encodeTax(t))
+      .find((tax) => taxOptions.some((opt) => opt.value === tax));
+  }
+}

package/src/helpers/number.ts

@@ -0,0 +1,25 @@
+
+
+export interface AdjustmentAmount {
+  amount: number;
+  precision: number;
+}
+
+export function toAdjustmentWithPrecision(
+  amt: string | number,
+  precision = 0,
+  allowNegative = false
+) {
+  let amount = 0;
+  if (!Number.isNaN(Number(amt))) {
+    if (allowNegative || Number(amt) >= 0) amount = Number(amt);
+  }
+  return {
+    amount: Number((amount * 10 ** precision).toFixed(0)),
+    precision
+  };
+}
+
+export function percentToAdjustment(v: number): AdjustmentAmount {
+  return toAdjustmentWithPrecision(Math.floor(v) / 100, 4);
+}

package/src/helpers/object.ts

@@ -0,0 +1,12 @@
+export function clone<T>(value: T, exceptKey: string[] = []): T {
+  const obj = JSON.parse(JSON.stringify(value));
+  if (exceptKey.length > 0) {
+    exceptKey.forEach((key): void => {
+      if (obj[key] !== undefined) {
+        delete obj[key];
+      }
+    });
+  }
+  return obj;
+}
+

package/src/helpers/profile.ts

@@ -0,0 +1,52 @@
+import { FdoProfile, FdoAddress } from '@feedmepos/core/entity';
+
+export interface Address extends FdoAddress {
+  formatted: string;
+  isValidPostcode: boolean;
+  isValid: boolean;
+  isValidCoordinate: boolean;
+}
+
+export interface Profile extends FdoProfile {
+  address: Address;
+}
+
+export function initAddress(): Address {
+  const v = {
+    line1: '',
+    line2: '',
+    city: '',
+    postcode: '',
+    state: '',
+    country: '',
+    coordinates: [],
+  };
+  return formatAddress(v);
+}
+
+export function formatAddress(address: any): Address {
+  return {
+    ...address,
+
+    get formatted(): string {
+      const { line1, line2, postcode, city, state, country } = address;
+      return [line1, (line2 || ''), postcode, city, state, country]
+        .map(v => v.replace(/,\s*$/, ''))
+        .filter(v => !!v.trim())
+        .join(', ');
+    },
+    get isValidPostcode(): boolean {
+      const res = Number.parseInt(address.postcode);
+      return !isNaN(res);
+    },
+    get isValid(): boolean {
+      const optionalFields: (keyof FdoAddress)[] = ['line2'];
+      return Object.keys(address)
+        .filter((key) => !optionalFields.includes(key as keyof FdoAddress))
+        .every(key => !!address[key as keyof FdoAddress]);
+    },
+    get isValidCoordinate(): boolean {
+      return (address.coordinates || []).length === 2;
+    },
+  };
+}

package/src/i18n.ts

@@ -0,0 +1,43 @@
+import type { App } from 'vue';
+import i18next from 'i18next';
+import I18NextVue from 'i18next-vue';
+
+export const appLocale = Object.freeze({
+  defaultLocale: 'en',
+  supportedLocales: [
+    {
+      label: 'English',
+      value: 'en',
+    },
+    {
+      label: '中文',
+      value: 'zh',
+    },
+  ],
+});
+
+export const i18nPromise = i18next
+  .init({
+    // debug: true,
+    ns: ['bill', 'business', 'common', 'device', 'inventory', 'kitchen', 'mall', 'marketing', 'menu', 'order', 'payment', 'printer', 'report', 'restaurant', 'system', 'table', 'transaction', 'user'],
+    backend: {
+      loadPath: '/locales/{{lng}}/{{ns}}.json',
+    },
+    fallbackLng: appLocale.defaultLocale,
+    i18nFormat: {
+      'capitalize': (value: string) => {
+        return value.charAt(0).toUpperCase() + value.slice(1);
+      },
+      'uppercase': (value: string) => {
+        return value.toUpperCase();
+      },
+      'lowercase': (value: string) => {
+        return value.toLowerCase();
+      },
+    }
+  });
+
+export default function (app: App) {
+  app.use(I18NextVue, { i18next });
+  return app;
+}

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;