sme-pos-package 1.0.7 → 1.0.9

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

@@ -0,0 +1,76 @@
+import { QUERY_KEYS } from "@constants/query.constant";
+import { useQueryParams } from "@hooks/common/use-query-params";
+import { useKitchen } from "@provider/pos-provider/kitchen-provider";
+import { useProduct } from "@provider/pos-provider/product-provider";
+import { TKitchenOrder } from "@type/order";
+import { TAttributeLine, TProduct } from "@type/product/product";
+import { useMemo, useState } from "react";
+
+const useOrders = () => {
+  const { getQuery } = useQueryParams();
+  const { displayDataQueryResult } = useKitchen();
+  const { data: products } = useProduct();
+
+  const displayData = useMemo(
+    () => displayDataQueryResult?.data,
+    [displayDataQueryResult]
+  );
+
+  const kitchenOrders = useMemo(() => displayData?.orders ?? [], [displayData]);
+
+  const statusId = Number(getQuery(QUERY_KEYS.KITCHEN_ORDER_STATUS));
+
+  const [searchValue, setSearchValue] = useState("");
+
+  const onSearchChange = (value: string) => {
+    setSearchValue(value);
+  };
+
+  const kitchenOrdersFiltered = useMemo(() => {
+    const productMap = new Map<number, TProduct>(
+      products?.map((item: TProduct) => [item.id, item])
+    );
+    return kitchenOrders
+      .filter((order: TKitchenOrder) => {
+        return order.stage_id === statusId;
+      })
+      .filter((order: TKitchenOrder) => {
+        return (
+          order.pos_order_id.toString().includes(searchValue) ||
+          order.orderlines.some((orderLine: any) => {
+            return (orderLine.product_name as string)
+              .toLowerCase()
+              .includes(searchValue.toLowerCase());
+          })
+        );
+      })
+      .map((order: TKitchenOrder) => {
+        return {
+          ...order,
+          orderlines: order.orderlines.map((orderLine: any) => {
+            const saleItem = productMap.get(orderLine.product_id);
+            return {
+              ...orderLine,
+              pickAttributeValue: saleItem?.attributeLines?.map(
+                (attributeLine: TAttributeLine) => {
+                  return {
+                    ...attributeLine,
+                    value_string: attributeLine.value_string.filter(
+                      (val: any) => orderLine.attribute_ids.includes(val.id)
+                    ),
+                  };
+                }
+              ),
+            };
+          }),
+        };
+      });
+  }, [kitchenOrders, products, searchValue, statusId]);
+
+  return {
+    kitchenOrdersFiltered,
+    onSearchChange,
+  };
+};
+
+export default useOrders;

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

@@ -0,0 +1,221 @@
+import { PublishType } from "@components/pos-management/payment-content/card-payment/pos-payment/qr-connect";
+import { ORDER_STATE } from "@constants/order-state";
+import { QUERY_KEYS } from "@constants/query.constant";
+import { useService } from "@fctc/widget-logic/provider";
+import { sessionStorageUtils } from "@fctc/widget-logic/utils";
+import { useQueryParams } from "@hooks/common/use-query-params";
+import { usePosAppProvider } from "@provider/app-provider";
+import { useOrderDetail } from "@provider/pos-provider/order-detail-provider";
+import { useOrder } from "@provider/pos-provider/order-provider";
+import { LoadDataModel } from "@provider/pos-provider/sale-provider";
+import { useSocketData } from "@provider/pos-provider/socket-provider";
+import { useMutation } from "@tanstack/react-query";
+import {
+  TCheckPaymentPayload,
+  TMakePaymentPayload,
+  TPaymentInfo,
+} from "@type/payment";
+import { useTranslation } from "react-i18next";
+import { toast } from "react-toastify";
+
+const usePaymentProvider = () => {
+  const {
+    useAddEntity,
+    useCheckPayment,
+    useGeneratePaymentQrInfo,
+    useUpdateOrderStatus,
+  } = useService();
+  const createEntityMutation = useAddEntity().mutateAsync;
+  const checkPaymentMutation = useCheckPayment().mutateAsync;
+  const generatePaymentQrInfoMutation = useGeneratePaymentQrInfo().mutateAsync;
+  const useUpdateOrderStatusMutation = useUpdateOrderStatus().mutateAsync;
+  const { user } = usePosAppProvider();
+  const { t } = useTranslation();
+  const { getQuery } = useQueryParams();
+
+  const { updateOrder, orders, setOrders } = useOrder();
+  const { onPaymentSuccess } = useOrderDetail();
+  const xNode = user?.userProfile?.data?.x_node;
+  const service = sessionStorageUtils.getMenuFocus().service || `wesap`;
+  const menuItemId = Number(getQuery(QUERY_KEYS.POS_ID));
+  const orderIdParam = getQuery(QUERY_KEYS.ORDER_ID);
+  const sessionIdParam = getQuery(QUERY_KEYS.SESSION_ID);
+
+  const { clientMtqq, onPublish } = useSocketData();
+  const posId = getQuery(QUERY_KEYS.POS_ID);
+  const mqttConnect = localStorage.getItem(`mttqQrConnect${posId}`) ?? "";
+  const makePayment = useMutation<[number], Error, TMakePaymentPayload>({
+    mutationFn: (payload: TMakePaymentPayload) =>
+      createEntityMutation({
+        model: LoadDataModel.POS_MAKE_PAYMENT,
+        values: {
+          config_id: menuItemId,
+          payment_method_id: payload.paymentMethodId,
+          amount: payload.amount,
+          payment_name: payload.paymentName,
+        },
+        isCreateEndpoint: true,
+        service: service ?? "",
+        xNode: xNode ?? "",
+      }) as Promise<[number]>,
+  });
+
+  const checkPayment = useMutation({
+    mutationFn: (payload: TCheckPaymentPayload) =>
+      checkPaymentMutation({
+        model: LoadDataModel.POS_MAKE_PAYMENT,
+        ids: [payload.id],
+        withContext: {
+          active_model: "pos.order",
+          active_id: payload.orderId,
+        },
+        service: service ?? "",
+        xNode: xNode ?? "",
+      }),
+  });
+
+  const payment = async (
+    payload: TMakePaymentPayload & { orderId: number }
+  ) => {
+    const makePaymentRes: [number] = await makePayment.mutateAsync({
+      paymentMethodId: payload.paymentMethodId,
+      amount: payload.amount,
+      paymentName: payload.paymentName,
+    });
+
+    const checkPaymentRes: any = await checkPayment.mutateAsync({
+      id: makePaymentRes[0],
+      orderId: payload.orderId,
+    });
+
+    return {
+      success: checkPaymentRes?.type === "ir.actions.act_window_close",
+      paymentId: makePaymentRes[0],
+    };
+  };
+
+  const handlePayment = async (
+    payload: TMakePaymentPayload & {
+      orderId: number;
+      receivedAmount: number;
+    }
+  ) => {
+    try {
+      const { orderId, receivedAmount, amount, paymentMethodId, paymentName } =
+        payload;
+
+      const paymentResult = await payment({
+        amount: receivedAmount,
+        orderId: Number(orderId),
+        paymentMethodId: paymentMethodId,
+        paymentName: paymentName,
+      });
+
+      if (paymentResult.success) {
+        onPaymentSuccess(amount);
+      } else {
+        const res = await updateOrder.mutateAsync({
+          orderId: Number(orderId),
+          amount_return: receivedAmount - amount,
+          state: ORDER_STATE.IN_PAID,
+        });
+        if (res) {
+          onPaymentSuccess(amount);
+        }
+      }
+    } catch (error) {
+      console.error("Payment failed:", error);
+      toast.error(`${t("paymentFailedTitle")}12312`);
+    }
+  };
+  // ir.actions.act_window
+  const generatePaymentQrInfo = useMutation({
+    mutationFn: ({
+      amount,
+      sessionId,
+      orderId,
+    }: {
+      amount: number;
+      sessionId?: string;
+      orderId?: string;
+    }) =>
+      generatePaymentQrInfoMutation({
+        orderId: Number(orderId || orderIdParam),
+        amount,
+        posSessionId: Number(sessionId || sessionIdParam),
+        service: "wesap",
+        xNode: xNode ?? "",
+      }) as Promise<TPaymentInfo>,
+  });
+
+  const onUpdateOrderStatus = async (orderId: number) => {
+    const res = await useUpdateOrderStatusMutation({
+      orderId: orderId,
+      state: ORDER_STATE.IN_PAID,
+      xNode: dataUser?.x_node,
+      service: "wesap",
+    });
+    if (res) {
+      setOrders(
+        orders.map((order) => {
+          if (order.id === orderId) {
+            return {
+              ...order,
+              state: ORDER_STATE.IN_PAID,
+            };
+          }
+          return order;
+        })
+      );
+    }
+    return res as Promise<{
+      name: string;
+    }>;
+  };
+
+  const onGeneratePaymentQrInfo = async (
+    amount: number,
+    sessionId?: string,
+    orderId?: string
+  ) => {
+    await onUpdateOrderStatus(Number(orderId || orderIdParam));
+    const data = await generatePaymentQrInfo.mutateAsync({
+      amount,
+      sessionId,
+      orderId,
+    });
+    return data;
+  };
+  const dataUser = user?.userProfile?.data;
+  const onRequestPayment = async (amount: number) => {
+    await onUpdateOrderStatus(Number(orderIdParam));
+    const data = await onUpdateOrderStatus(Number(orderIdParam));
+    if (!clientMtqq) return;
+    onPublish(
+      mqttConnect,
+      JSON.stringify({
+        payload: {
+          orderId: data?.name,
+          amount: amount,
+          topic: mqttConnect,
+        },
+        type: PublishType.Payment,
+      })
+    );
+  };
+
+  const onPaymentSoftPos = async (amount: number) => {
+    toast.error("Chức năng đang được phát triển");
+  };
+
+  return {
+    handlePayment,
+    onGeneratePaymentQrInfo,
+    onRequestPayment,
+    onPaymentSoftPos,
+  };
+};
+
+export default usePaymentProvider;
+
+export type usePaymentProviderType = ReturnType<typeof usePaymentProvider>;

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

@@ -0,0 +1,87 @@
+import { LoadDataModel, useSale } from "@provider/pos-provider/sale-provider";
+import { useCartStore } from "@store/states/cart.state";
+import {
+  TAttributeLine,
+  TAttributeLineData,
+  TAttributeValueData,
+  TProduct,
+  TProductAttribute,
+} from "@type/product/product";
+import { getProductIdFromKey } from "@utils/functions";
+import { useMemo } from "react";
+
+const useProductProvider = () => {
+  const {
+    queryResult: { isLoading },
+    getData,
+  } = useSale();
+
+  const productsData = getData(LoadDataModel.PRODUCT_PRODUCT) as TProduct[];
+  const attributesValueData = getData(
+    LoadDataModel.PRODUCT_TEMPLATE_ATTRIBUTE_VALUE
+  ) as TAttributeValueData[];
+
+  const attributesLinesData = getData(
+    LoadDataModel.PRODUCT_TEMPLATE_ATTRIBUTE_LINE
+  ) as TAttributeLineData[];
+
+  const productAttributes = getData(
+    LoadDataModel.PRODUCT_ATTRIBUTE
+  ) as TProductAttribute[];
+
+  const { activeProduct } = useCartStore();
+
+  const taxesData = getData(LoadDataModel.ACCOUNT_TAX);
+
+  const productWithImageAndTax: TProduct[] = useMemo(() => {
+    return (
+      productsData?.map((product) => {
+        const taxes = taxesData
+          ?.filter((tax: any) => product?.taxes_id?.includes(tax?.id))
+          .map((tax: any) => tax?.amount || 0);
+        const temp: TAttributeLine[] =
+          product?.attribute_line_ids?.map((attributeLineId: number) => {
+            const attribute = attributesLinesData?.find(
+              (attributeLine: any) => attributeLine.id === attributeLineId
+            );
+            return {
+              id: attribute?.id ?? 0,
+              name: attribute?.display_name ?? "",
+              value_string: attributesValueData
+                ?.filter(
+                  (attributeValue: TAttributeValueData) =>
+                    attributeValue.attribute_line_id === attributeLineId
+                )
+                ?.map((attributeValue: TAttributeValueData) => {
+                  return attributeValue;
+                }),
+              type:
+                productAttributes?.find((attribute: TProductAttribute) =>
+                  attribute?.attributeValueIds?.includes(attributeLineId)
+                )?.display_type ?? "pills",
+            };
+          }) ?? [];
+        return {
+          ...product,
+
+          tax: taxes?.reduce((acc: number, tax: number) => acc + tax, 0) || 0,
+          attributeLines: temp,
+        };
+      }) || []
+    );
+  }, [productsData, taxesData]);
+  const productData: TProduct | undefined = useMemo(() => {
+    if (!productsData || !activeProduct) return;
+
+    return productWithImageAndTax?.find(
+      (item: TProduct) =>
+        item.id.toString() === getProductIdFromKey(activeProduct.id)
+    );
+  }, [productWithImageAndTax, activeProduct]);
+  return { data: productWithImageAndTax, isLoading, productData };
+};
+
+export default useProductProvider;
+
+export type useProductProviderType = ReturnType<typeof useProductProvider>;
+export const defaultProductImage = "/product-default.png";

package/src/hooks/session/use-check-session.tsx

@@ -0,0 +1,19 @@
+import { LoadDataModel, useSale } from "@provider/pos-provider/sale-provider";
+
+const useCheckSession = () => {
+  const { getData } = useSale();
+
+  const onCheckSession = async () => {
+    const currentPos = getData(LoadDataModel.POS_CONFIG)?.[0];
+
+    const isSessionOpened = currentPos.pos_session_state === "opened";
+
+    return isSessionOpened;
+  };
+
+  return {
+    onCheckSession,
+  };
+};
+
+export default useCheckSession;

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

@@ -0,0 +1,79 @@
+import { useService } from "@fctc/widget-logic/provider";
+import { sessionStorageUtils } from "@fctc/widget-logic/utils";
+import { usePosAppProvider } from "@provider/app-provider";
+import { useMutation } from "@tanstack/react-query";
+
+const useSessionProvider = () => {
+  const { useCreateSession, useHandleClosingSession, useCreatePosConfig } =
+    useService();
+
+  const createSessionMutation = useCreateSession().mutateAsync;
+  const setOpeningCashBoxMutation = useHandleClosingSession().mutateAsync;
+  const createPosConfigMutation = useCreatePosConfig().mutateAsync;
+
+  const { user } = usePosAppProvider();
+  const dataUser = user?.userProfile?.data;
+  const service = sessionStorageUtils.getMenuFocus().service || `wesap`;
+  const xNode = dataUser?.x_node || "";
+
+  const openSession = useMutation({
+    mutationFn: async (configId: number) => {
+      return await createSessionMutation({
+        configId,
+        model: "pos.session",
+        service,
+        xNode,
+      });
+    },
+  });
+
+  const setOpeningCashBox = useMutation({
+    mutationFn: ({
+      cashBoxValue,
+      sessionId,
+    }: {
+      cashBoxValue: number;
+      sessionId: number;
+    }) => {
+      return setOpeningCashBoxMutation({
+        model: "pos.session",
+        ids: [Number(sessionId)],
+        service,
+        xNode,
+        method: "set_opening_control",
+        kwargs: {
+          cashbox_value: cashBoxValue,
+          notes: "Opening cashbox",
+        },
+      });
+    },
+  });
+
+  const createPosConfig = useMutation({
+    mutationFn: async ({
+      name,
+      modulePosRestaurant,
+    }: {
+      name: string;
+      modulePosRestaurant: string;
+    }) => {
+      return await createPosConfigMutation({
+        model: "pos.config",
+        name,
+        service,
+        xNode,
+        modulePosRestaurant,
+      });
+    },
+  });
+
+  return {
+    openSession,
+    setOpeningCashBox,
+    createPosConfig,
+  };
+};
+
+export default useSessionProvider;
+
+export type useSessionProviderType = ReturnType<typeof useSessionProvider>;

package/src/hooks/table/use-pos-table-provider.ts

@@ -0,0 +1,193 @@
+import { ORDER_STATE } from "@constants/order-state";
+import { QUERY_KEYS } from "@constants/query.constant";
+import { useService } from "@fctc/widget-logic/provider";
+import usePos from "@hooks/common/use-pos";
+import { useQueryParams } from "@hooks/common/use-query-params";
+import { useOrder } from "@provider/pos-provider/order-provider";
+import { LoadDataModel, useSale } from "@provider/pos-provider/sale-provider";
+import { useMutation } from "@tanstack/react-query";
+import { TBasicTable, TCreateTablePayload, TMapedTable } from "@type/table";
+import { t } from "i18next";
+import { useEffect, useMemo, useState } from "react";
+import { toast } from "react-toastify";
+
+const usePosTableProvider = (enabled = true) => {
+  const { useCreateEntity, useUpdateEntity } = useService();
+  const createEntityMutation = useCreateEntity().mutateAsync;
+  const updateEntityMutation = useUpdateEntity().mutateAsync;
+  const { xNode, service } = usePos();
+  const { getData } = useSale();
+  const { getQuery } = useQueryParams();
+  const [tables, setTables] = useState<TBasicTable[]>([]);
+
+  const createTable = useMutation({
+    mutationFn: (payload: TCreateTablePayload) =>
+      createEntityMutation({
+        model: LoadDataModel.RESTAURANT_TABLE,
+        args: [
+          {
+            table_number: payload.tableNumber,
+            floor_id: payload.floorId,
+            seats: payload.seats,
+          },
+        ],
+        service: service ?? "",
+        xNode: xNode ?? "",
+      }),
+  });
+
+  const deleteTable = useMutation({
+    mutationFn: (tableId: number) =>
+      updateEntityMutation({
+        model: LoadDataModel.RESTAURANT_TABLE,
+        domain: [["id", "=", tableId]],
+        values: {
+          active: false,
+        },
+        service: service ?? "",
+        xNode: xNode ?? "",
+      }),
+  });
+
+  const updateTable = useMutation({
+    mutationFn: (payload: {
+      tableId: number;
+      tableNumber: string;
+      seats: number;
+    }) =>
+      updateEntityMutation({
+        model: LoadDataModel.RESTAURANT_TABLE,
+        domain: [["id", "=", payload.tableId]],
+        values: {
+          table_number: payload.tableNumber,
+          seats: payload.seats,
+        },
+        service: service ?? "",
+        xNode: xNode ?? "",
+      }),
+  });
+
+  const onCreateTable = async (payload: TCreateTablePayload) => {
+    const newTable = await createTable.mutateAsync(payload);
+    if (newTable) {
+      const newTableId = (newTable as any[][])?.[0]?.[0] as number;
+      setTables([
+        ...tables,
+        {
+          id: newTableId,
+          table_number: payload.tableNumber,
+          floor_id: payload.floorId,
+          seats: payload.seats,
+        },
+      ]);
+      toast.success("Thêm bàn thành công");
+    }
+  };
+
+  const onDeleteTable = async (tableId: number, onSuccess?: () => void) => {
+    const deleteTableId = await deleteTable.mutateAsync(tableId);
+    if (deleteTableId) {
+      setTables(tables.filter((t) => t.id !== tableId));
+      toast.success(t("deleteTableSuccess"));
+      onSuccess && onSuccess();
+    }
+  };
+
+  const onUpdateTable = async (payload: {
+    tableId: number;
+    tableNumber: string;
+    seats: number;
+    onSuccess?: () => void;
+  }) => {
+    const updateTableId = await updateTable.mutateAsync(payload);
+    if (updateTableId) {
+      setTables(
+        tables.map((table) =>
+          table.id === payload.tableId
+            ? {
+                ...table,
+                table_number: Number(payload.tableNumber),
+                seats: payload.seats,
+              }
+            : table
+        )
+      );
+      toast.success(t("updateTableSuccess"));
+      payload.onSuccess && payload.onSuccess();
+    }
+  };
+  const floorId = getQuery(QUERY_KEYS.FLOOR);
+
+  const tablesByFloor = useMemo(() => {
+    const tablesFloor = floorId
+      ? tables?.filter((table) => table.floor_id === Number(floorId))
+      : [];
+    return [
+      {
+        id: 0,
+        table_number: 0,
+        floor_id: 0,
+        seats: 0,
+      },
+      ...tablesFloor,
+    ];
+  }, [tables, floorId]);
+
+  useEffect(() => {
+    if (enabled && getData) {
+      const tables = getData(LoadDataModel.RESTAURANT_TABLE) as TBasicTable[];
+      tables && setTables(tables);
+    }
+  }, [getData]);
+
+  const { orders } = useOrder();
+  const mapTablesWithOrder: TMapedTable[] = useMemo(() => {
+    return tablesByFloor.map((table) => {
+      const isTakeAway = table.id === 0;
+      const currentOrder = orders?.find((order) => {
+        return table.id === 0
+          ? false
+          : table.id?.toString() === order.table_id?.toString() &&
+              (order.state === ORDER_STATE.NEW ||
+                order.state === ORDER_STATE.IN_PAID);
+      });
+      return {
+        table: {
+          id: table.id,
+          table_number: table.table_number,
+          floor_id: table.floor_id,
+          seats: table.seats,
+        },
+        isTakeAway: isTakeAway,
+        currentOrder: currentOrder
+          ? {
+              id: currentOrder?.id,
+              table_id: currentOrder?.table_id,
+              state: currentOrder?.state,
+              create_date: currentOrder?.create_date,
+              pos_reference: currentOrder?.pos_reference,
+              amount_total: currentOrder?.amount_total,
+              amount_tax: currentOrder?.amount_tax,
+              user_id: currentOrder?.user_id,
+              partner_id: currentOrder?.partner_id,
+              write_date: currentOrder?.write_date,
+              lines: currentOrder?.lines,
+            }
+          : undefined,
+      };
+    });
+  }, [tablesByFloor, orders]);
+
+  return {
+    tables,
+    tablesByFloor,
+    mapTablesWithOrder,
+    onCreateTable,
+    onDeleteTable,
+    onUpdateTable,
+  };
+};
+
+export default usePosTableProvider;
+
+export type usePosTableProviderType = ReturnType<typeof usePosTableProvider>;

package/src/index.css

@@ -0,0 +1,5 @@
+.custom {
+  color: red;
+  background-color: blue;
+  font-size: 20px;
+}

package/src/index.ts

@@ -0,0 +1,10 @@
+export * from "./components";
+export * from "./constants";
+export * from "./layouts";
+export * from "./pages";
+export { default as PosAppProvider } from "./provider/app-provider";
+export { default as SocketProvider } from "./provider/pos-provider/socket-provider";
+export { default as PublicProvider } from "./provider/public-provider";
+export { default as AppProvider } from "./router/app-router";
+export { default as createPOSRoutes } from "./router/pos-route";
+import "./index.css";