sme-pos-package 1.0.7 → 1.0.9

package/src/provider/pos-provider/order-provider/index.tsx

@@ -0,0 +1,803 @@
+import { FIND_PARTNER_CODE } from "@constants/api";
+import { METHOD } from "@constants/methods.constant";
+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 { useSpeech } from "@hooks/common/use-speech";
+import { usePosAppProvider } from "@provider/app-provider";
+import { CartItemType, useCartStore } from "@store/states/cart.state";
+import { useMutation } from "@tanstack/react-query";
+import { TBasicCustomer, TCustomer } from "@type/customer";
+import { ApiOrder, TBasicOrder, TOrderPayload } from "@type/order";
+import {
+  TAddProductToOrderPayload,
+  TOnUpdateOrderLineQuantity,
+  TRemoveProductPayload,
+  TUpdateOrderPayload,
+  TUpdateOrderTotalAmount,
+} from "@type/product";
+import { TAttributeLine, TProduct } from "@type/product/product";
+import {
+  add7Hours,
+  cleanObject,
+  generatePosReference,
+  getKey,
+  isObjectEmpty,
+  makeTaxIds,
+} from "@utils/functions";
+import { convertOrders } from "@utils/pos/convert-order";
+import { t } from "i18next";
+import {
+  createContext,
+  useCallback,
+  useContext,
+  useEffect,
+  useMemo,
+  useState,
+} from "react";
+import { useNavigate, useSearchParams } from "react-router-dom";
+import { toast } from "react-toastify";
+import { useKitchen } from "../kitchen-provider";
+import { LoadDataModel, useSale } from "../sale-provider";
+import POSPath from "@constants/routes.constants";
+
+export type useOrderProviderType = ReturnType<typeof useOrderProvider>;
+
+const ReactContext = createContext<useOrderProviderType>(
+  {} as useOrderProviderType
+);
+
+export const OrderProvider = ({ children }: { children: React.ReactNode }) => {
+  return (
+    <ReactContext.Provider value={useOrderProvider()}>
+      {children}
+    </ReactContext.Provider>
+  );
+};
+
+export type TDomainCondition = [string, string, any];
+
+const useOrderProvider = ({
+  enabled = true,
+}: {
+  enabled?: boolean;
+} = {}) => {
+  const {
+    useCreateEntity,
+    useUpdateEntity,
+    useGetOrderLine,
+    useDeleteEntity,
+    useAddEntity,
+    useProcessOrder,
+    useGetCurrentUser,
+  } = useService();
+  const createEntityMutation = useCreateEntity().mutateAsync;
+  const getOrderLineMutation = useGetOrderLine().mutateAsync;
+  const updateEntityMutation = useUpdateEntity().mutateAsync;
+  const deleteEntityMutation = useDeleteEntity().mutateAsync;
+  const addEntityMutation = useAddEntity().mutateAsync;
+  const processOrderMutation = useProcessOrder().mutateAsync;
+  const getCurrentUserMutation = useGetCurrentUser().mutateAsync;
+
+  const { getSpec, getData } = useSale();
+  const { user } = usePosAppProvider();
+  const xNode = user?.userProfile?.data?.x_node;
+  const service = sessionStorageUtils.getMenuFocus().service || `wesap`;
+  const [searchParams] = useSearchParams();
+  const sessionId = searchParams.get(QUERY_KEYS.SESSION_ID);
+  const orderId = searchParams.get(QUERY_KEYS.ORDER_ID);
+  const [extraDomain, setExtraDomain] = useState<TDomainCondition[]>([
+    ["session_id", "=", Number(sessionId)],
+  ]);
+  const { removeParam, formatQuery } = useQueryParams();
+  const { setMapKitchenWithPOS, isPosMapKitchen } = useKitchen();
+  const orderLineSpec = getSpec(LoadDataModel.POS_ORDER_LINE);
+  const users = getData(LoadDataModel.RES_USERS);
+  const walkInCustomer = useMemo(() => {
+    return getData(LoadDataModel.RES_PARTNER)?.find(
+      (user: TBasicCustomer) => user.code === FIND_PARTNER_CODE
+    );
+  }, [users]);
+
+  const { updateMultipleQuery } = useQueryParams();
+  const [orders, setOrders] = useState<TBasicOrder[]>([]);
+
+  useEffect(() => {
+    const ordersData = getData(LoadDataModel.POS_ORDER) as ApiOrder[];
+    if (ordersData && !isObjectEmpty(ordersData)) {
+      setOrders(convertOrders(ordersData));
+    }
+  }, [getData]);
+
+  const orderDetailById = useMemo(() => {
+    if (orderId) {
+      return orders.find((order) => order.id === Number(orderId));
+    }
+  }, [orders, orderId]);
+
+  const draftOrders = useMemo(() => {
+    return orders.filter(
+      (order) =>
+        order.state === ORDER_STATE.NEW || order.state === ORDER_STATE.IN_PAID
+    );
+  }, [orders]);
+
+  const createOrderMutate = useMutation({
+    mutationFn: useCallback(
+      (payload: TOrderPayload) =>
+        createEntityMutation({
+          model: LoadDataModel.POS_ORDER,
+          args: [
+            cleanObject({
+              session_id: payload.sessionId,
+              pos_reference: payload.posReference,
+              amount_tax: payload.amountTax,
+              amount_total: payload.amountTotal,
+              amount_paid: payload.amountPaid,
+              amount_return: payload.amountReturn,
+              table_id: payload.tableId,
+              partner_id: payload.partnerId,
+            }),
+          ],
+          service: service ?? "",
+          xNode: xNode ?? "",
+        }),
+      [createEntityMutation, service, xNode]
+    ),
+  });
+
+  const { cartItems, dec, remove, add, clear, activeProduct } = useCartStore();
+
+  const posSessionData = getData(LoadDataModel.POS_SESSION);
+
+  const posReference = useMemo(() => {
+    const data = posSessionData?.[0];
+    const length = orders?.length || 0;
+    if (
+      data === undefined ||
+      data?.id === undefined ||
+      data?.login_number === undefined
+    ) {
+      return undefined;
+    }
+    return generatePosReference({
+      posId: data.id,
+      loginNum: data.login_number,
+      orderLength: length,
+    });
+  }, [posSessionData, orders]);
+
+  const handleCreateOrder = async (tableId?: number) => {
+    clear();
+    try {
+      let payload: any = {
+        sessionId: Number(sessionId),
+        posReference,
+        amountTax: 0,
+        amountTotal: 0,
+        amountPaid: 0,
+        amountReturn: 0,
+        partnerId: walkInCustomer.id,
+      };
+      if (tableId) {
+        payload = {
+          ...payload,
+          tableId,
+        };
+      }
+      const order = await createOrderMutate.mutateAsync(payload);
+      if (order) {
+        const orderId = (order as []).flat()[0] as number;
+        const time = add7Hours(new Date());
+        setOrders([
+          {
+            id: orderId,
+            table_id: tableId ?? false,
+            state: ORDER_STATE.NEW,
+            lines: [],
+            create_date: time,
+            pos_reference: posReference ?? "",
+            amount_total: 0,
+            amount_tax: 0,
+            user_id: user?.id,
+            partner_id: walkInCustomer.id,
+            write_date: time,
+          },
+          ...orders,
+        ]);
+      }
+      return order;
+    } catch (error) {
+      toast.error("Tạo đơn hàng không thành công");
+      console.error(error);
+    }
+  };
+
+  const handleCancelOrder = async (onSuccess?: () => void) => {
+    try {
+      const res = (await cancelOrder.mutateAsync([Number(orderId)])) as {
+        [LoadDataModel.POS_ORDER]: any;
+      };
+      if (res?.[LoadDataModel.POS_ORDER]?.[0]?.id) {
+        removeParam([QUERY_KEYS.ORDER_ID, QUERY_KEYS.TABLE_ID]);
+        setOrders(
+          orders.filter(
+            (order) =>
+              order.id !== Number(res?.[LoadDataModel.POS_ORDER]?.[0]?.id)
+          )
+        );
+        onSuccess && onSuccess();
+      }
+    } catch (error) {
+      console.error(error);
+      toast.error("Huỷ đơn hàng không thành công");
+    }
+  };
+
+  const [loadingChangeQty, setLoadingChangeQty] = useState(false);
+
+  const addProductToOrder = useMutation<
+    [number],
+    Error,
+    TAddProductToOrderPayload
+  >({
+    mutationFn: (payload: TAddProductToOrderPayload) =>
+      addEntityMutation({
+        model: LoadDataModel.POS_ORDER_LINE,
+        values: {
+          order_id: payload.orderId,
+          product_id: payload.productId,
+          qty: payload.qty,
+          price_subtotal: payload.priceSubtotal,
+          price_subtotal_incl: payload.priceSubtotalIncl,
+          price_unit: payload.priceUnit,
+          tax_ids: [makeTaxIds(payload.taxIds)],
+          uuid: `${payload.productId}-${payload.attribute_value_ids
+            ?.map((item) => item)
+            .join("-")}`,
+          attribute_value_ids: payload.attribute_value_ids
+            ? [[6, 0, payload.attribute_value_ids]]
+            : [],
+        },
+        isCreateEndpoint: true,
+        service: service ?? "",
+        xNode: xNode ?? "",
+      }) as Promise<[number]>,
+  });
+
+  const updateOrderTotalAmount = useMutation({
+    mutationFn: (payload: TUpdateOrderTotalAmount) =>
+      updateEntityMutation({
+        model: LoadDataModel.POS_ORDER,
+        domain: [["id", "=", payload.orderId]],
+        values: {
+          amount_tax: payload.amountTax,
+          amount_total: payload.amountTotal,
+          note: payload.note,
+        },
+        service: service ?? "",
+        xNode: xNode ?? "",
+      }),
+  });
+
+  const addProduct = async (
+    payload: TAddProductToOrderPayload & {
+      amountTax: number;
+      amountTotal: number;
+    }
+  ) => {
+    try {
+      setLoadingChangeQty(true);
+      const addProductToOrderRes = await addProductToOrder.mutateAsync({
+        orderId: payload.orderId,
+        productId: payload.productId,
+        qty: payload.qty,
+        priceUnit: payload.priceUnit,
+        priceSubtotal: payload.priceSubtotal,
+        priceSubtotalIncl: payload.priceSubtotalIncl,
+        taxIds: payload.taxIds,
+        attribute_value_ids: payload.attribute_value_ids,
+        note: payload.note,
+      });
+
+      onUpdateOrderTotalAmount({
+        orderId: payload.orderId,
+        amountTax: payload.amountTax,
+        amountTotal: payload.amountTotal,
+        note: payload?.note,
+      });
+      return addProductToOrderRes;
+    } catch (err) {
+      console.error("add product failed", err);
+    } finally {
+      setLoadingChangeQty(false);
+    }
+  };
+
+  const getOrderLine = useMutation({
+    mutationFn: useCallback(
+      (ids: number[]) =>
+        getOrderLineMutation({
+          model: LoadDataModel.POS_ORDER_LINE,
+          ids,
+          specification: {
+            ...orderLineSpec,
+          },
+          service: service ?? "",
+          xNode: xNode ?? "",
+        }),
+      [getOrderLineMutation, orderLineSpec, service, xNode]
+    ),
+  });
+
+  const updateOrder = useMutation({
+    mutationFn: useCallback(
+      (payload: TUpdateOrderPayload) =>
+        updateEntityMutation({
+          model: LoadDataModel.POS_ORDER,
+          domain: [["id", "=", payload.orderId]],
+          values: cleanObject({
+            state: payload.state,
+            table_id: payload.tableId,
+            partner_id: payload.partnerId,
+            amount_return: payload.amount_return,
+          }),
+          service: service ?? "",
+          xNode: xNode ?? "",
+        }),
+      [updateEntityMutation, service, xNode]
+    ),
+  });
+
+  const cancelOrder = useMutation({
+    mutationFn: useCallback(
+      (ids: number[]) =>
+        deleteEntityMutation({
+          model: LoadDataModel.POS_ORDER,
+          ids,
+          service: service ?? "",
+          xNode: xNode ?? "",
+          method: METHOD.ACTION_POS_ORDER_CANCEL,
+        }),
+      [deleteEntityMutation, service, xNode]
+    ),
+  });
+
+  const deleteProductFromOrder = useMutation({
+    mutationFn: useCallback(
+      (lineIds: number[]) =>
+        deleteEntityMutation({
+          model: LoadDataModel.POS_ORDER_LINE,
+          ids: lineIds,
+          service: service ?? "",
+          xNode: xNode ?? "",
+          method: METHOD.UNLINK,
+        }),
+      [deleteEntityMutation, service, xNode]
+    ),
+  });
+
+  const onUpdateLineOrderQuantity = useMutation({
+    mutationFn: useCallback(
+      (payload: TOnUpdateOrderLineQuantity) =>
+        updateEntityMutation({
+          model: LoadDataModel.POS_ORDER_LINE,
+          domain: [["id", "=", payload.orderLineId]],
+          values: {
+            order_id: payload.orderId,
+            qty: payload.qty,
+            price_subtotal: payload.priceSubtotal,
+            price_subtotal_incl: payload.priceSubtotalIncl,
+            attribute_value_ids: payload.attributeValueIds,
+          },
+          service: service ?? "",
+          xNode: xNode ?? "",
+        }),
+      [updateEntityMutation, service, xNode]
+    ),
+  });
+
+  const onProductQuantityChange = async (
+    payload: TOnUpdateOrderLineQuantity & {
+      amountTax: number;
+      amountTotal: number;
+      note?: string;
+    }
+  ) => {
+    try {
+      setLoadingChangeQty(true);
+      await onUpdateLineOrderQuantity.mutateAsync(payload);
+
+      onUpdateOrderTotalAmount({
+        orderId: payload.orderId,
+        amountTax: payload.amountTax,
+        amountTotal: payload.amountTotal,
+        note: payload?.note,
+      });
+    } catch (err) {
+      console.error("on product change quantity failed", err);
+    } finally {
+      setLoadingChangeQty(false);
+    }
+  };
+
+  const onUpdateOrderTotalAmount = async (payload: {
+    orderId: number;
+    amountTax: number;
+    amountTotal: number;
+    note?: string;
+  }) => {
+    const res = await updateOrderTotalAmount.mutateAsync({
+      orderId: payload.orderId,
+      amountTax: payload.amountTax,
+      amountTotal: payload.amountTotal,
+      note: payload?.note,
+    });
+    res &&
+      setOrders(
+        orders.map((order) => {
+          if (order.id === payload.orderId) {
+            return {
+              ...order,
+              amount_tax: payload.amountTax,
+              amount_total: payload.amountTotal,
+            };
+          }
+          return order;
+        })
+      );
+  };
+
+  const onRemoveProduct = async (product: TProduct) => {
+    const productKey = activeProduct.isFromCart
+      ? product.productCartKey ?? getKey(product)
+      : getKey(product);
+    const lineId = cartItems[productKey]?.lineId;
+    if (!lineId) {
+      console.error("lineId not found");
+      return;
+    }
+
+    const { total, totalIncl } = getTotal({
+      ...cartItems,
+      [productKey]: {
+        ...cartItems?.[getKey(product)],
+        product: product,
+        qty: 0,
+      },
+    });
+    await removeProduct({
+      orderId: Number(orderId),
+      amountTax: totalIncl - total,
+      amountTotal: totalIncl,
+      lineIds: lineId,
+    });
+    remove(productKey);
+    return;
+  };
+
+  const changeProductQty = async ({ ...props }: CartItemType) => {
+    const { product, qty } = props;
+    const currentQty = cartItems[getKey(product)]?.qty || 0;
+    const productKey =
+      activeProduct.isFromCart && product.productCartKey
+        ? product.productCartKey
+        : getKey(product);
+    const exist = cartItems?.[productKey];
+    const totalProductPrice = getTotalProductPrice(product);
+
+    const onGetPrice = (qty: number) => {
+      const { total, totalIncl } = getTotal({
+        ...cartItems,
+        [productKey]: {
+          ...cartItems?.[getKey(product)],
+          product: product,
+          qty: qty,
+        },
+      });
+      return {
+        total,
+        totalIncl,
+      };
+    };
+    const onAdd = async () => {
+      const { total, totalIncl } = onGetPrice(qty);
+      return await addProduct({
+        orderId: Number(orderId),
+        productId: product.id,
+        qty,
+        amountTax: totalIncl - total,
+        amountTotal: totalIncl,
+        priceUnit: product.lst_price,
+        priceSubtotal: totalProductPrice * qty,
+        priceSubtotalIncl:
+          Number((totalProductPrice * (1 + product.tax * 0.01)).toFixed(2)) *
+          qty,
+        taxIds: product.taxes_id,
+        attribute_value_ids: product.attributeValueIds || [],
+      });
+    };
+
+    if (!activeProduct.isFromCart && qty == 0) return;
+    if (exist) {
+      const lineId = cartItems[productKey]?.lineId || props?.lineId;
+      if (!lineId) {
+        console.error("lineId not found");
+        return;
+      }
+
+      const onChange = async () => {
+        const realQty =
+          qty == -1
+            ? currentQty - 1
+            : activeProduct.isFromCart
+            ? qty
+            : currentQty + qty;
+
+        const { total, totalIncl } = onGetPrice(realQty);
+
+        await onProductQuantityChange({
+          orderId: Number(orderId),
+          orderLineId: lineId[0],
+          qty: realQty,
+          priceSubtotal: totalProductPrice * realQty,
+          priceSubtotalIncl:
+            Number((totalProductPrice * (1 + product.tax * 0.01)).toFixed(2)) *
+            realQty,
+          amountTax: totalIncl - total,
+          amountTotal: totalIncl,
+          attributeValueIds: product.attributeValueIds,
+          note: props?.note,
+        });
+        if (product.productCartKey !== getKey(product)) {
+          product.productCartKey && remove(product.productCartKey);
+          add({
+            product: { ...product, productCartKey: getKey(product) },
+            qty: realQty - currentQty,
+            lineId: [lineId[0]],
+          });
+        } else
+          add({
+            product,
+            qty: realQty - currentQty,
+            lineId: [lineId[0]],
+          });
+
+        return;
+      };
+
+      const onDec = async () => {
+        await deleteProductFromOrder.mutateAsync(lineId);
+        const res = await onAdd();
+        if (!res) return;
+        if (product.productCartKey !== getKey(product)) {
+          product.productCartKey && remove(product.productCartKey);
+          dec(getKey(product), qty, res);
+        } else {
+          dec(productKey, currentQty - qty, res);
+        }
+        return;
+      };
+
+      const onRemove = async () => {
+        const { total, totalIncl } = onGetPrice(0);
+        await removeProduct({
+          orderId: Number(orderId),
+          amountTax: totalIncl - total,
+          amountTotal: totalIncl,
+          lineIds: lineId,
+        });
+        remove(productKey);
+        return;
+      };
+
+      if (activeProduct.isFromCart && qty === 0) onRemove();
+      else if (activeProduct.isFromCart && qty < currentQty) onDec();
+      else onChange();
+
+      //remove
+    } else {
+      const res = await onAdd();
+      res &&
+        add({
+          product,
+          qty,
+          lineId: [res?.[0]],
+        });
+    }
+  };
+
+  const removeProduct = async (payload: TRemoveProductPayload) => {
+    try {
+      await deleteProductFromOrder.mutateAsync(payload.lineIds);
+
+      onUpdateOrderTotalAmount({
+        orderId: payload.orderId,
+        amountTax: payload.amountTax,
+        amountTotal: payload.amountTotal,
+      });
+    } catch (err) {
+      console.error("remove product failed", err);
+    }
+  };
+
+  const onUpdateCustomer = async ({
+    customer,
+    onSuccess,
+  }: {
+    customer: TCustomer;
+    onSuccess?: () => void;
+  }) => {
+    if (!orderId) return;
+
+    await updateOrder.mutateAsync({
+      orderId: Number(orderId),
+      partnerId: customer.id,
+    });
+    setOrders(
+      orders.map((order) => {
+        if (order.id === Number(orderId)) {
+          return {
+            ...order,
+            partner_id: customer.id,
+          };
+        }
+        return order;
+      })
+    );
+    onSuccess && onSuccess();
+  };
+
+  const onRemoveCustomer = async () => {
+    if (!orderId) return;
+
+    await updateOrder.mutateAsync({
+      orderId: Number(orderId),
+      partnerId: 0,
+    });
+    setOrders(
+      orders.map((order) => {
+        if (order.id === Number(orderId)) {
+          return {
+            ...order,
+            partner_id: walkInCustomer.id,
+          };
+        }
+        return order;
+      })
+    );
+  };
+
+  const partnerIdQueryResult = getData(LoadDataModel.RES_PARTNER);
+
+  const onProcessOrder = useMutation({
+    mutationFn: async (orderId: number) => {
+      return await processOrderMutation({
+        orderId,
+        service: service ?? "",
+        xNode: xNode ?? "",
+      });
+    },
+  });
+
+  const onCallDish = async () => {
+    if (!orderId || !isPosMapKitchen) return;
+    try {
+      await onProcessOrder.mutateAsync(Number(orderId));
+      // props is new order line
+      setMapKitchenWithPOS(null);
+      // refetchDisplayDataResult();
+      toast.success(t("callDishSuccess"));
+    } catch (error: any) {
+      toast.error(error);
+    }
+  };
+  const { speak } = useSpeech();
+  const navigate = useNavigate();
+  const onPaymentSuccess = (total: number) => {
+    console.log("onPaymentSuccess");
+    speak(`Thanh toán thành công, ${total} đồng`);
+    navigate({
+      pathname: POSPath.SUCCESS,
+      search: `?${formatQuery([
+        QUERY_KEYS.POS_ID,
+        QUERY_KEYS.SESSION_ID,
+        QUERY_KEYS.ORDER_ID,
+      ])}`,
+    });
+  };
+
+  const onGetCurrentUser = async ({ userId }: { userId: number }) => {
+    const oauthId = await users?.find((user: any) => user.id === userId)
+      ?.oauth_uid;
+
+    const userMatched = await getCurrentUserMutation({
+      service: "mms",
+      xNode: xNode ?? "",
+      oauthUid: oauthId ?? "Chưa xác định",
+    });
+
+    return userMatched?.name ?? "Chưa xác định";
+  };
+
+  return {
+    onProcessOrder,
+    handleCreateOrder,
+    getOrderLine,
+    updateOrder,
+    cancelOrder,
+    changeProductQty,
+    loadingChangeQty,
+    partnerIdQueryResult,
+    setExtraDomain,
+    extraDomain,
+    onCallDish,
+    onPaymentSuccess,
+    onRemoveProduct,
+    onGetCurrentUser,
+    orders,
+    setOrders,
+    draftOrders,
+    orderDetailById,
+    handleCancelOrder,
+    onUpdateCustomer,
+    onRemoveCustomer,
+  };
+};
+export default useOrderProvider;
+export const useOrder = () => {
+  const context = useContext(ReactContext);
+
+  if (!context) {
+    throw new Error("useOrder must be used within a OrderProvider");
+  }
+
+  return context;
+};
+export function getTotalProductPrice(product: TProduct) {
+  const totalAttributesValue =
+    product.pickAttributeValue?.reduce(
+      (acc: number, attributeValue: TAttributeLine) => {
+        return (
+          acc +
+          attributeValue.value_string.reduce(
+            (total: number, item: any) => total + item.price_extra,
+            0
+          )
+        );
+      },
+      0
+    ) ?? 0;
+  return totalAttributesValue + product.lst_price;
+}
+
+function getTotal(items: Record<string, CartItemType>) {
+  const totalIncl = Object.values(items).reduce(
+    (acc: number, item: CartItemType) => {
+      return (
+        acc +
+        Number(
+          (
+            getTotalProductPrice(item.product) *
+            (1 + item.product.tax * 0.01)
+          ).toFixed(2)
+        ) *
+          item.qty
+      );
+    },
+    0
+  );
+  const total = Object.values(items).reduce(
+    (acc: number, item: CartItemType) => {
+      return acc + getTotalProductPrice(item.product) * item.qty;
+    },
+    0
+  );
+
+  return {
+    totalIncl,
+    total,
+  };
+}