sme-pos-package 1.0.7 → 1.0.9

package/src/hooks/customer/use-customer-provider.ts

@@ -0,0 +1,247 @@
+import { useService } from "@fctc/widget-logic/provider";
+import useGetQuery from "@hooks/common/use-get-query";
+
+import usePos from "@hooks/common/use-pos";
+import { TDomainCondition } from "@provider/pos-provider/order-provider";
+import { LoadDataModel, useSale } from "@provider/pos-provider/sale-provider";
+import { useMutation, useQuery } from "@tanstack/react-query";
+import {
+  TCustomerPayload,
+  TCustomerRes,
+  TUpdateCustomerPayload,
+} from "@type/customer";
+import { useMemo, useState } from "react";
+import { useTranslation } from "react-i18next";
+
+const useCustomerProvider = () => {
+  const { t } = useTranslation("customer");
+
+  const {
+    useGetList,
+    useCreateEntity,
+    useUpdateEntity,
+    useGetProductImage,
+    useGetWard,
+    useGetCity,
+    useGetPartnerTitle,
+  } = useService();
+  const { getSpec } = useSale();
+  const { service, xNode } = usePos();
+  const { orderId, sessionId } = useGetQuery();
+
+  const getListMutation = useGetList().mutateAsync;
+  const getCustomerMutation = useGetProductImage().mutateAsync;
+  const createEntityMutation = useCreateEntity().mutateAsync;
+  const updateEntityMutation = useUpdateEntity().mutateAsync;
+  const getWardMutation = useGetWard().mutateAsync;
+  const getCityMutation = useGetCity().mutateAsync;
+  const getPartnerTitle = useGetPartnerTitle().mutateAsync;
+
+  const [stateId, setStateId] = useState("");
+
+  const partnerSpec = getSpec(LoadDataModel.RES_PARTNER);
+
+  const [extraDomain, setExtraDomain] = useState<TDomainCondition[]>([
+    ["phone", "=", ""],
+  ]);
+
+  const queryResult = useQuery<TCustomerRes>({
+    queryKey: [
+      "get-customer",
+      service,
+      xNode,
+      sessionId,
+      extraDomain,
+      partnerSpec,
+    ],
+    queryFn: () => {
+      return getListMutation({
+        model: "res.partner",
+        domain: extraDomain,
+        service: service ?? "",
+        xNode: xNode ?? "",
+        offset: 0,
+        limit: 100,
+        specification: partnerSpec,
+      }) as Promise<TCustomerRes>;
+    },
+    enabled:
+      !!service &&
+      !!xNode &&
+      !!sessionId &&
+      !!partnerSpec &&
+      !!extraDomain?.[0]?.[2],
+  });
+
+  const createCustomerMutation = useMutation({
+    mutationFn: (payload: TCustomerPayload) =>
+      createEntityMutation({
+        model: "res.partner",
+        args: [payload],
+        service: service ?? "",
+        xNode: xNode ?? "",
+      }),
+  });
+
+  const refreshListCustomer = async () => {
+    setExtraDomain([["phone", "=", ""]]);
+    await queryResult.refetch();
+  };
+
+  const createCustomer = async ({ payload }: { payload: TCustomerPayload }) => {
+    const customerId = await createCustomerMutation
+      .mutateAsync(payload)
+      .then((res) => {
+        return (res as Array<Array<number | undefined>>)[0][0];
+      });
+    if (!customerId)
+      throw new Error(t("create.add_customer_to_order.toast_error"));
+    else return customerId;
+  };
+
+  const updateCustomer = useMutation({
+    mutationFn: (payload: TUpdateCustomerPayload) =>
+      updateEntityMutation({
+        model: "res.partner",
+        domain: [["id", "=", payload.id]],
+        values: {
+          ...payload,
+        },
+        service: service ?? "",
+        xNode: xNode ?? "",
+      }),
+  });
+
+  const getCustomer = useMutation({
+    mutationFn: ({ customerId }: { customerId: number }) =>
+      getCustomerMutation({
+        model: "res.partner",
+        fields: ["id", "name", "phone", "contact_address_inline", "email"],
+        limit: 10,
+        offset: 0,
+        domain: [["id", "=", customerId]],
+        service: service ?? "",
+        xNode: xNode ?? "",
+      }),
+  });
+
+  const getCityQueryResult = useQuery({
+    queryKey: ["get-city", service, xNode],
+    queryFn: () => {
+      return getCityMutation({
+        service: service ?? "",
+        xNode: xNode ?? "",
+        ids: [],
+        kwargs: {
+          count_limit: 10001,
+          domain: [["country_id", "=", 241]],
+          offset: 0,
+          order: "",
+          specification: {
+            id: {},
+            name: {},
+            display_name: {},
+          },
+        },
+      });
+    },
+    enabled: !!service && !!xNode,
+  });
+
+  const cities = useMemo(() => {
+    return getCityQueryResult?.data?.records?.map((city: any) => {
+      return {
+        id: city.id,
+        name: city.name,
+      };
+    });
+  }, [getCityQueryResult?.data?.records]);
+
+  const getWardQueryResult = useQuery({
+    queryKey: ["get-ward", service, xNode, stateId],
+    queryFn: () => {
+      return getWardMutation({
+        service: service ?? "",
+        xNode: xNode ?? "",
+        kwargs: {
+          count_limit: 10001,
+          domain: [["state_id", "=", Number(stateId)]],
+          offset: 0,
+          order: "",
+          specification: {
+            id: {},
+            name: {},
+            display_name: {},
+          },
+        },
+      });
+    },
+    enabled: !!service && !!xNode && !!stateId,
+  });
+
+  const wards = useMemo(() => {
+    return (
+      getWardQueryResult?.data?.records?.map((ward: any) => {
+        return {
+          id: ward.id,
+          name: ward.name,
+        };
+      }) ?? []
+    );
+  }, [getWardQueryResult?.data?.records]);
+
+  const getPartnerTitleQueryResult = useQuery({
+    queryKey: ["get-partner-title", service, xNode],
+    queryFn: () => {
+      return getPartnerTitle({
+        service: service ?? "",
+        xNode: xNode ?? "",
+        kwargs: {
+          count_limit: 10001,
+          domain: [],
+          offset: 0,
+          order: "",
+          specification: {
+            id: {},
+            name: {},
+            display_name: {},
+          },
+        },
+        withContext: {
+          lang: "vi_VN",
+          tz: "Asia/Saigon",
+        },
+      });
+    },
+    enabled: !!service && !!xNode,
+  });
+
+  const partnerTitles = useMemo(() => {
+    return getPartnerTitleQueryResult?.data?.records?.map((title: any) => {
+      return {
+        id: title.id,
+        name: title.name,
+      };
+    });
+  }, [getPartnerTitleQueryResult?.data?.records]);
+
+  return {
+    queryResult,
+    updateCustomer,
+    createCustomer,
+    setExtraDomain,
+    refreshListCustomer,
+    extraDomain,
+    orderId,
+    getCustomer,
+    cities,
+    wards,
+    partnerTitles,
+    stateId,
+    setStateId,
+  };
+};
+
+export default useCustomerProvider;
+
+export type useCustomerProviderType = ReturnType<typeof useCustomerProvider>;

package/src/hooks/floor/use-floor-provider.ts

@@ -0,0 +1,172 @@
+import { useService } from "@fctc/widget-logic/provider";
+import { LoadDataModel, useSale } from "@provider/pos-provider/sale-provider";
+import { usePosTable } from "@provider/pos-provider/table-provider";
+import { useMutation } from "@tanstack/react-query";
+import { TFloor, TTableId } from "@type/floor/floor";
+import { isObjectEmpty } from "@utils/functions";
+import { t } from "i18next";
+import { useEffect, useMemo, useState } from "react";
+import { toast } from "react-toastify";
+const useFloorProvider = ({
+  service,
+  xNode,
+  enabled = true,
+  posConfigId,
+}: {
+  service: string;
+  xNode: string;
+  enabled: boolean;
+  posConfigId: number;
+}) => {
+  const { useCreateEntity, useUpdateEntity } = useService();
+  const createEntityMutation = useCreateEntity().mutateAsync;
+  const updateEntityMutation = useUpdateEntity().mutateAsync;
+  const { tables } = usePosTable();
+  const createFloor = useMutation({
+    mutationFn: ({ name }: { name: string }) => {
+      return createEntityMutation({
+        model: LoadDataModel.RESTAURANT_FLOOR,
+        args: [
+          {
+            name,
+            pos_config_ids: [posConfigId],
+          },
+        ],
+        service: service ?? "",
+        xNode: xNode ?? "",
+      });
+    },
+  });
+
+  const updateFloor = useMutation({
+    mutationFn: (payload: { floorId: number; name: string }) =>
+      updateEntityMutation({
+        model: LoadDataModel.RESTAURANT_FLOOR,
+        domain: [["id", "=", payload.floorId]],
+        values: {
+          name: payload.name,
+        },
+        service: service ?? "",
+        xNode: xNode ?? "",
+      }),
+  });
+
+  const deleteFloor = useMutation({
+    mutationFn: ({ floorId }: { floorId: number }) =>
+      updateEntityMutation({
+        model: LoadDataModel.RESTAURANT_FLOOR,
+        domain: [["id", "=", floorId]],
+        values: {
+          active: false,
+        },
+        service: service ?? "",
+        xNode: xNode ?? "",
+      }),
+  });
+
+  const [floors, setFloors] = useState<TFloor[]>([]);
+  const { getData } = useSale();
+
+  const mapFloors = useMemo(() => {
+    return floors.map((floor) => {
+      const tableIds: TTableId[] = tables
+        ?.filter((table) => table.floor_id === floor.id)
+        ?.map((table) => {
+          return {
+            id: table.id,
+            table_number: table.table_number,
+          };
+        });
+      return { ...floor, table_ids: tableIds };
+    });
+  }, [floors]);
+
+  const onCreateFloor = async (name: string, onSuccess?: () => void) => {
+    try {
+      const newFloor = await createFloor.mutateAsync({ name });
+      if (newFloor) {
+        const newFloorId = (newFloor as any[][])?.[0]?.[0] as number;
+        setFloors([
+          ...floors,
+          { id: newFloorId, name, table_ids: [], pos_config_ids: [] },
+        ]);
+        toast.success("Tạo tầng thành công"); //TODO
+        onSuccess && onSuccess();
+      }
+    } catch (error) {
+      console.error("Create floor error:", error);
+    }
+  };
+
+  const onUpdateFloor = async (
+    floorId: number,
+    name: string,
+    onSuccess?: () => void
+  ) => {
+    try {
+      const updatedFloor = await updateFloor.mutateAsync({ floorId, name });
+      if (updatedFloor) {
+        setFloors(
+          floors.map((floor) => {
+            if (floor.id === floorId) {
+              return { ...floor, name };
+            }
+            return floor;
+          })
+        );
+        toast.success("Chỉnh sửa tầng thành công"); //TODO
+        onSuccess && onSuccess();
+      }
+    } catch (error) {
+      console.error("Update floor error:", error);
+    }
+  };
+
+  const onDeleteFloor = async (floorId: number, onSuccess?: () => void) => {
+    try {
+      const deletedFloor = await deleteFloor.mutateAsync({ floorId });
+      if (deletedFloor) {
+        setFloors(floors.filter((floor) => floor.id !== floorId));
+        toast.success(t("deleteFloorSuccess"));
+        onSuccess && onSuccess();
+      }
+    } catch (error) {
+      console.error("Delete floor error:", error);
+    }
+  };
+
+  const tableOfOrder = (tableId: number | false, orderId: number) => {
+    const mapTable = tables.find((table) => table.id === tableId);
+    const mapFloor = mapFloors.find((floor) =>
+      floor.table_ids?.some((table) => table.id === mapTable?.id)
+    );
+    return {
+      fullName: `${
+        mapFloor
+          ? `${mapFloor?.name} - Bàn ${mapTable?.table_number}`
+          : `Mang đi`
+      }    `,
+      floorId: mapFloor?.id ?? floors[0]?.id,
+      tableId: mapTable?.id,
+    };
+  };
+
+  useEffect(() => {
+    if (getData && enabled) {
+      const floors = getData(LoadDataModel.RESTAURANT_FLOOR) as TFloor[];
+      floors && !isObjectEmpty(floors ?? {}) && setFloors(floors);
+    }
+  }, [getData]);
+
+  return {
+    floors: mapFloors,
+    onCreateFloor,
+    onUpdateFloor,
+    onDeleteFloor,
+    tableOfOrder,
+  };
+};
+
+export default useFloorProvider;
+
+export type useFloorProviderType = ReturnType<typeof useFloorProvider>;

package/src/hooks/kitchen/use-kitchen-provider.ts

@@ -0,0 +1,80 @@
+import { useService } from "@fctc/widget-logic/provider";
+import { useMutation, useQuery } from "@tanstack/react-query";
+
+import useGetQuery from "@hooks/common/use-get-query";
+import usePos from "@hooks/common/use-pos";
+import { usePosAppProvider } from "@provider/app-provider";
+import { LoadDataModel, useSale } from "@provider/pos-provider/sale-provider";
+import { TChangeOrderStatusPayload } from "@type/order";
+import { useEffect, useMemo, useState } from "react";
+import { useParams } from "react-router-dom";
+
+const useKitchenProvider = () => {
+  const { useGetPreparationDisplayData, useChangeOrderPreparationState } =
+    useService();
+
+  const getPreparationDisplayDataMutation =
+    useGetPreparationDisplayData().mutateAsync;
+  const changeOrderPreparationStateMutation =
+    useChangeOrderPreparationState().mutateAsync;
+  const [mapKitchenWithPOS, setMapKitchenWithPOS] = useState<any>(null);
+  const params = useParams();
+  const { service, xNode } = usePos();
+  const { posId } = useGetQuery();
+
+  const { getData } = useSale();
+
+  useEffect(() => {
+    setMapKitchenWithPOS(
+      getData(LoadDataModel.POS_PREPARATION_DISPLAY_DISPLAY)
+    );
+  }, [getData]);
+
+  const isPosMapKitchen = useMemo(() => {
+    return !!mapKitchenWithPOS;
+  }, [mapKitchenWithPOS, posId]);
+
+  const kitchenId = posId ? mapKitchenWithPOS?.id : Number(params.kitchenId);
+  const { user } = usePosAppProvider();
+  const displayDataQueryResult = useQuery<any>({
+    queryKey: ["get-display-data", service, xNode, kitchenId],
+    queryFn: () => {
+      return getPreparationDisplayDataMutation({
+        ids: kitchenId,
+        service: service ?? "",
+        xNode: xNode ?? "",
+        withContext: {
+          uid: user?.userProfile?.data?.sub,
+          lang: "vi_VN",
+          tz: "Asia/Saigon",
+        },
+      });
+    },
+    enabled: !!service && !!xNode && !!kitchenId,
+  });
+
+  const changeOrderPreparationState = useMutation({
+    mutationFn: (payload: TChangeOrderStatusPayload) => {
+      return changeOrderPreparationStateMutation({
+        orderId: payload.orderId,
+        service: service ?? "",
+        xNode: xNode ?? "",
+        stageId: payload.stageId,
+        preparationDisplayId: payload.preparationDisplayId,
+      });
+    },
+  });
+
+  return {
+    displayDataQueryResult,
+    displayDataRefresh: displayDataQueryResult.refetch,
+    changeOrderPreparationState,
+    isPosMapKitchen,
+    mapKitchenWithPOS,
+    setMapKitchenWithPOS,
+  };
+};
+
+export default useKitchenProvider;
+
+export type useKitchenProviderType = ReturnType<typeof useKitchenProvider>;

package/src/hooks/order/use-get-point-reward.ts

@@ -0,0 +1,50 @@
+import { useMemo } from "react";
+import { useSale, LoadDataModel } from "@provider/pos-provider/sale-provider";
+import { isObjectEmpty } from "@utils/functions";
+
+const useGetPointReward = ({
+  totalAmountWithoutTax,
+}: {
+  totalAmountWithoutTax: number;
+}) => {
+  const saleData = useSale();
+
+  const loyaltyProgram = useMemo(() => {
+    if (!saleData) return;
+
+    return saleData.getData(LoadDataModel.LOYALTY_PROGRAM);
+  }, [saleData]);
+
+  const loyaltyRule = useMemo(() => {
+    if (!saleData) return;
+
+    return saleData.getData(LoadDataModel.LOYALTY_RULE);
+  }, [saleData]);
+
+  const rewardId = useMemo(() => {
+    if (!loyaltyProgram) return;
+
+    return loyaltyProgram?.[0]?.reward_ids[0];
+  }, [loyaltyProgram]);
+
+  const amount = useMemo(() => {
+    if (!loyaltyRule || isObjectEmpty(loyaltyRule)) return;
+    const ruleMatched = loyaltyRule.find((rule: any) => rule.id === rewardId);
+
+    return {
+      minimumAmount: ruleMatched.minimum_amount,
+      rewardPointAmount: ruleMatched.reward_point_amount,
+    };
+  }, [loyaltyRule, rewardId]);
+
+  const pointReward =
+    amount?.minimumAmount && amount?.rewardPointAmount
+      ? Math.floor(totalAmountWithoutTax * amount.rewardPointAmount)
+      : 0;
+
+  return {
+    pointReward,
+  };
+};
+
+export default useGetPointReward;

package/src/hooks/order/use-loop-fetch-order.ts

@@ -0,0 +1,30 @@
+import { ORDER_STATE } from "@constants/order-state";
+import { useOrder } from "@provider/pos-provider/order-provider";
+import { useSale } from "@provider/pos-provider/sale-provider";
+import { useEffect, useMemo } from "react";
+
+const useLoopFetchOrder = () => {
+  const { orderDetailById, onPaymentSuccess } = useOrder();
+  const { queryResult } = useSale();
+
+  const orderState = useMemo(() => {
+    return orderDetailById?.state;
+  }, [orderDetailById]);
+
+  useEffect(() => {
+    const interval = setInterval(() => {
+      if (
+        orderState === ORDER_STATE.IN_PAID ||
+        orderState === ORDER_STATE.NEW
+      ) {
+        queryResult.refetch();
+      }
+    }, 3000);
+
+    return () => {
+      clearInterval(interval);
+    };
+  }, []);
+};
+
+export default useLoopFetchOrder;

package/src/hooks/order/use-order-items.ts

@@ -0,0 +1,61 @@
+import { useOrder } from "@provider/pos-provider/order-provider";
+import { useProduct } from "@provider/pos-provider/product-provider";
+import { useSale } from "@provider/pos-provider/sale-provider";
+import { useQuery } from "@tanstack/react-query";
+import { OrderDetailItemType } from "@type/index";
+import { TProduct } from "@type/product/product";
+import { useMemo } from "react";
+
+export const useOrderItems = () => {
+  const { getOrderLine, orderDetailById } = useOrder();
+  const { data: products, isLoading } = useProduct();
+  const {
+    queryResult: { data: saleData },
+  } = useSale();
+
+  const lines = useMemo(() => orderDetailById?.lines, [orderDetailById]);
+
+  const {
+    data: orderLines,
+    isLoading: orderLinesLoading,
+    refetch,
+  } = useQuery<any>({
+    queryKey: ["orderItems", lines, products],
+    queryFn: () => getOrderLine.mutateAsync(lines as number[]),
+    enabled: !!lines && !!products,
+  });
+  const items: OrderDetailItemType[] = useMemo(() => {
+    const productMap = new Map<number, TProduct>(
+      products?.map((item: TProduct) => [item.id, item])
+    );
+
+    return (
+      orderLines?.map((item: any) => {
+        const saleItem = productMap.get(item.product_id);
+        const res: OrderDetailItemType = {
+          id: item.product_id,
+          name: saleItem?.name || item.name || "Sản phẩm",
+          quantity: item.qty,
+          price: item.price_unit,
+          image: saleItem?.image_128 || "",
+          unitPrice: item.price_unit,
+          subTotal: item.price_subtotal,
+          inchTotal: item.price_subtotal_incl,
+          taxesId: item.tax_ids,
+          lineId: item.id,
+          tax: saleItem?.tax || 0,
+          attributeValueIds: item.attribute_value_ids,
+        };
+        return res;
+      }) || []
+    );
+  }, [orderLines, products]);
+
+  return {
+    items,
+    isLoading: orderLinesLoading || isLoading,
+    // staffName: saleData?.["res.users"]?.data,
+    customerName: saleData?.["res.partner"]?.data,
+    refetchOrderLines: refetch,
+  };
+};