sme-pos-package 1.0.7 → 1.0.9

package/src/provider/pos-provider/close-session-provider/index.tsx

@@ -0,0 +1,207 @@
+import { useService } from "@fctc/widget-logic/provider";
+import { useMutation, useQuery } from "@tanstack/react-query";
+import { createContext, useContext, useMemo } from "react";
+import { useSearchParams } from "react-router-dom";
+
+import { METHOD } from "@constants/methods.constant";
+import { ORDER_STATE } from "@constants/order-state";
+import { QUERY_KEYS } from "@constants/query.constant";
+import { sessionStorageUtils } from "@fctc/widget-logic/utils";
+import { usePosAppProvider } from "@provider/app-provider";
+import { TBasicOrder } from "@type/order";
+import { toast } from "react-toastify";
+import { useOrder } from "../order-provider";
+
+const Context = createContext<{
+  draftInPaidOrders: TBasicOrder[];
+  getDataCloseSessionQuery: any;
+  closeSession: ({
+    countedCash,
+    notes,
+  }: {
+    countedCash: number;
+    notes: string;
+  }) => Promise<boolean | undefined | TCloseSessionRes>;
+}>({
+  draftInPaidOrders: [],
+  getDataCloseSessionQuery: {},
+  closeSession: () => Promise.resolve(true),
+});
+
+const Provider = ({ children }: { children: React.ReactNode }) => {
+  const {
+    useHandleCloseSession,
+    useHandleClosingDetailSession,
+    useUpdateEntity,
+  } = useService();
+  const handleCloseSession = useHandleCloseSession().mutateAsync;
+  const updateEntityMutation = useUpdateEntity().mutateAsync;
+  const handleClosingDetailSessionMutation =
+    useHandleClosingDetailSession().mutateAsync;
+
+  const [searchParams] = useSearchParams();
+  const sessionId = searchParams.get(QUERY_KEYS.SESSION_ID);
+  const { user } = usePosAppProvider();
+  const xNode = user?.userProfile?.data?.x_node;
+  const service = sessionStorageUtils.getMenuFocus().service || `wesap`;
+
+  const commonPayload = useMemo(() => {
+    return { model: "pos.session", ids: [Number(sessionId)], service, xNode };
+  }, [service, sessionId, xNode]);
+
+  const { orders } = useOrder();
+
+  const draftInPaidOrders = orders.filter(
+    (item) => item.state == ORDER_STATE.NEW || item.state == ORDER_STATE.IN_PAID
+  );
+
+  const getDataCloseSession = useMutation({
+    mutationFn: async () => {
+      return await handleCloseSession({
+        ...commonPayload,
+        method: METHOD.GET_CLOSING_CONTROL_DATA,
+      });
+    },
+  });
+
+  const getDataCloseSessionQuery = useQuery({
+    queryKey: [
+      "get-data-close-session",
+      service,
+      xNode,
+      commonPayload,
+      sessionId,
+    ],
+    queryFn: () => {
+      if (!commonPayload) return Promise.resolve(null);
+      return getDataCloseSession.mutateAsync();
+    },
+    enabled: !!service && !!xNode && !!commonPayload && !!sessionId,
+  });
+
+  const closingDetail = useMutation({
+    mutationFn: (countedCash: number) => {
+      return handleClosingDetailSessionMutation({
+        ...commonPayload,
+        method: METHOD.POST_CLOSING_CASH_DETAILS,
+        kwargs: {
+          counted_cash: countedCash,
+        },
+      }) as Promise<{ successful: boolean }>;
+    },
+  });
+
+  const updateClosingStateSession = useMutation({
+    mutationFn: async (notes: string) => {
+      return await handleClosingDetailSessionMutation({
+        ...commonPayload,
+        method: METHOD.UPDATE_CLOSING_CONTROL_STATE_SESSION,
+        kwargs: {
+          notes,
+        },
+      });
+    },
+  });
+
+  const actionCloseSession = useMutation({
+    mutationFn: async () => {
+      return (await handleCloseSession({
+        ...commonPayload,
+        method: METHOD.ACTION_POS_SESSION_CLOSING_CONTROL,
+      })) as Promise<boolean | TCloseSessionRes>;
+    },
+  });
+
+  const forceCloseSession = useMutation({
+    mutationFn: async () => {
+      return (await handleCloseSession({
+        ...commonPayload,
+        method: METHOD.ACTION_POS_SESSION_CLOSE,
+      })) as Promise<boolean>;
+    },
+  });
+
+  const updateSessionCloseDate = useMutation({
+    mutationFn: () =>
+      updateEntityMutation({
+        model: "pos.session",
+        domain: [["id", "=", sessionId]],
+        values: {
+          stop_at: new Date().toISOString().slice(0, 19).replace("T", " "),
+          state: "closed",
+        },
+        service: service ?? "",
+        xNode: xNode ?? "",
+      }),
+  });
+
+  const closeSessionSuccessHandler = () => {
+    toast.success("Đóng ca thành công");
+  };
+
+  const onForceCloseSession = () => {
+    forceCloseSession.mutateAsync().then((res) => {
+      if (res) {
+        updateSessionCloseDate.mutateAsync().then(() => {
+          closeSessionSuccessHandler();
+        });
+      } else {
+        toast.error("Close session failed");
+      }
+    });
+  };
+
+  const closeSession = async ({
+    countedCash,
+    notes,
+  }: {
+    countedCash: number;
+    notes: string;
+  }) => {
+    try {
+      closingDetail.mutateAsync(countedCash);
+    } catch (error) {
+      console.error(error);
+      onForceCloseSession();
+      return;
+    }
+
+    await updateClosingStateSession.mutateAsync(notes);
+
+    const actionCloseSessionRes = await actionCloseSession.mutateAsync();
+
+    if (actionCloseSessionRes && typeof actionCloseSessionRes === "boolean") {
+      closeSessionSuccessHandler();
+    } else {
+      onForceCloseSession();
+    }
+
+    return actionCloseSessionRes;
+  };
+
+  return (
+    <Context.Provider
+      value={{
+        draftInPaidOrders,
+        getDataCloseSessionQuery,
+        closeSession,
+      }}
+    >
+      {children}
+    </Context.Provider>
+  );
+};
+
+export const CloseSessionProvider = Provider;
+
+export function useCloseSession() {
+  const context = useContext(Context);
+
+  if (!context) {
+    throw new Error(
+      "useCloseSession must be used within a CloseSessionProvider"
+    );
+  }
+
+  return context;
+}

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

@@ -0,0 +1,30 @@
+import useCustomerProvider, {
+  useCustomerProviderType,
+} from "@hooks/customer/use-customer-provider"
+import { createContext, useContext } from "react"
+
+const ReactContext = createContext<useCustomerProviderType>(
+  {} as useCustomerProviderType
+)
+
+export const CustomerProvider = ({
+  children,
+}: {
+  children: React.ReactNode
+}) => {
+  return (
+    <ReactContext.Provider value={useCustomerProvider()}>
+      {children}
+    </ReactContext.Provider>
+  )
+}
+
+export const useCustomer = () => {
+  const context = useContext(ReactContext)
+
+  if (!context) {
+    throw new Error("useCustomer must be used within a CustomerProvider")
+  }
+
+  return context
+}

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

@@ -0,0 +1,39 @@
+import useGetQuery from "@hooks/common/use-get-query";
+import usePos from "@hooks/common/use-pos";
+import useFloorProvider, {
+  useFloorProviderType,
+} from "@hooks/floor/use-floor-provider";
+import { createContext, useContext } from "react";
+
+const ReactContext = createContext<useFloorProviderType>(
+  {} as useFloorProviderType
+);
+
+export const FloorProvider = ({ children }: { children: React.ReactNode }) => {
+  const { dataUser, service } = usePos();
+
+  const { posId } = useGetQuery();
+
+  const queryResult = useFloorProvider({
+    service,
+    xNode: dataUser?.x_node || "",
+    enabled: !!dataUser?.x_node && !!service && !!posId,
+    posConfigId: posId,
+  });
+
+  return (
+    <ReactContext.Provider value={queryResult}>
+      {children}
+    </ReactContext.Provider>
+  );
+};
+
+export const useFloor = () => {
+  const context = useContext(ReactContext);
+
+  if (!context) {
+    throw new Error("useFloor must be used within a FloorProvider");
+  }
+
+  return context;
+};

package/src/provider/pos-provider/index.ts

@@ -0,0 +1,6 @@
+export * from "./sale-provider";
+export * from "./order-provider";
+export * from "./product-provider";
+export * from "./close-session-provider";
+export * from "./socket-provider";
+export * from "./payment-provider";

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

@@ -0,0 +1,30 @@
+import useKitchenProvider, {
+  useKitchenProviderType,
+} from "@hooks/kitchen/use-kitchen-provider"
+import { createContext, useContext } from "react"
+
+const ReactContext = createContext<useKitchenProviderType>(
+  {} as useKitchenProviderType
+)
+
+export const KitchenProvider = ({
+  children,
+}: {
+  children: React.ReactNode
+}) => {
+  return (
+    <ReactContext.Provider value={useKitchenProvider()}>
+      {children}
+    </ReactContext.Provider>
+  )
+}
+
+export const useKitchen = () => {
+  const context = useContext(ReactContext)
+
+  if (!context) {
+    throw new Error("useKitchen must be used within a KitchenProvider")
+  }
+
+  return context
+}

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

@@ -0,0 +1,233 @@
+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 { OrderDetailItemType } from "@type/index";
+import { TAttributeLine, TProduct } from "@type/product/product";
+import { t } from "i18next";
+import { createContext, useContext, useEffect, useMemo, useState } from "react";
+import { useNavigate } from "react-router-dom";
+import { toast } from "react-toastify";
+import { getTotalProductPrice, useOrder } from "../order-provider";
+import { useProduct } from "../product-provider";
+import { LoadDataModel, useSale } from "../sale-provider";
+import POSPath from "@constants/routes.constants";
+
+const useOrderDetailProvider = () => {
+  const { orderDetailById } = useOrder();
+  const { data: products, isLoading } = useProduct();
+  const { getData } = useSale();
+  const { addList, clear, cartItems } = useCartStore();
+
+  const { getQuery, formatQuery } = useQueryParams();
+  const orderId = getQuery(QUERY_KEYS.ORDER_ID);
+
+  const orderState = useMemo(() => {
+    return orderDetailById?.state;
+  }, [orderDetailById]);
+
+  const orderLines = useMemo(() => {
+    return (getData(LoadDataModel.POS_ORDER_LINE) ?? []).filter(
+      (item: any) => item.order_id === Number(orderId)
+    );
+  }, [getData, orderId]);
+
+  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 || t("product"),
+          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,
+          attributeLines: saleItem?.attributeLines,
+          pos_categ_ids: saleItem?.pos_categ_ids || [],
+          note: item.note,
+        };
+        return res;
+      }) || []
+    );
+  }, [orderLines, products]);
+
+  const cartItemsArr = useMemo(() => {
+    const cartArr = Object.values(cartItems).map((item: CartItemType) => {
+      const totalProductPrice = getTotalProductPrice({
+        ...item.product,
+      });
+      return {
+        ...item,
+        subTotal: totalProductPrice * item.qty,
+        inchTotal:
+          Number(
+            (totalProductPrice * (1 + item.product.tax * 0.01)).toFixed(2)
+          ) * item.qty,
+      };
+    });
+    return cartArr;
+  }, [cartItems, items]);
+
+  const totalAmount = useMemo(() => {
+    const value = cartItemsArr.reduce(
+      (sum, item) => sum + (item.subTotal ?? 0),
+      0
+    );
+    return value;
+  }, [cartItemsArr]);
+
+  const taxAmount = useMemo(() => {
+    const value = cartItemsArr.reduce(
+      (sum, item) => sum + (item.inchTotal ?? 0),
+      0
+    );
+    return value - totalAmount;
+  }, [totalAmount]);
+
+  const totalQty = useMemo(() => {
+    const value = cartItemsArr.reduce((sum, item) => sum + item.qty, 0);
+    return value;
+  }, [cartItemsArr]);
+  const { useCreateEInvoice } = useService();
+  const createEInvoiceMutation = useCreateEInvoice().mutateAsync;
+  const { user } = usePosAppProvider();
+  const xNode = user?.userProfile?.data?.x_node;
+  const service = sessionStorageUtils.getMenuFocus().service || `wesap`;
+  const [isEInvoiceCreating, setIsEInvoiceCreating] = useState(false);
+
+  const onCreateEInvoice = async () => {
+    try {
+      setIsEInvoiceCreating(true);
+      await createEInvoiceMutation({
+        service: service ?? "",
+        xNode: xNode ?? "",
+        kwargs: {},
+        ids: [Number(orderId)],
+      });
+
+      toast.success("Xuất hoá đơn thành công");
+      setIsEInvoiceCreating(false);
+    } catch (error: any) {
+      toast.error(error?.message);
+      console.log("create e invoice error", error);
+    } finally {
+      setIsEInvoiceCreating(false);
+    }
+  };
+  const { speak } = useSpeech();
+  const navigate = useNavigate();
+  const onPaymentSuccess = (total: number) => {
+    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,
+      ])}`,
+    });
+  };
+
+  useEffect(() => {
+    clear();
+    const orderItems: CartItemType[] = items?.map(
+      (item: OrderDetailItemType) => {
+        const pickAttributeValue = item.attributeLines?.map(
+          (attributeLine: TAttributeLine) => {
+            return {
+              ...attributeLine,
+              value_string: attributeLine.value_string?.filter(
+                (attributeValue: any) =>
+                  item.attributeValueIds?.includes(attributeValue.id)
+              ),
+            };
+          }
+        );
+        const product: TProduct = {
+          id: item.id,
+          name: item.name,
+          lst_price: item.price,
+          image_128: item.image,
+          taxes_id: item.taxesId,
+          tax: item.tax,
+          pos_categ_ids: item.pos_categ_ids ?? [],
+          attributeValueIds: item.attributeValueIds,
+          pickAttributeValue: pickAttributeValue,
+        };
+        return {
+          product: product,
+          qty: item.quantity,
+          lineId: [item.lineId],
+          subTotal: item.subTotal,
+          inchTotal: item.inchTotal,
+          note: item.note,
+        };
+      }
+    );
+    addList(orderItems);
+  }, [items]);
+
+  return {
+    onCreateEInvoice,
+    isEInvoiceCreating,
+    items,
+    isLoading: isLoading,
+    // staffName: saleData?.["res.users"]?.data,
+    customer: getData(LoadDataModel.RES_PARTNER)?.find(
+      (item: any) => item.id === Number(orderDetailById?.partner_id)
+    ),
+    refetchOrderLines: {},
+    totalAmount,
+    taxAmount,
+    totalQty,
+    orderState,
+    onPaymentSuccess,
+  };
+};
+export default useOrderDetailProvider;
+
+export type useOrderDetailProviderType = ReturnType<
+  typeof useOrderDetailProvider
+>;
+
+const ReactContext = createContext<useOrderDetailProviderType>(
+  {} as useOrderDetailProviderType
+);
+
+export const OrderDetailProvider = ({
+  children,
+}: {
+  children: React.ReactNode;
+}) => {
+  return (
+    <ReactContext.Provider value={useOrderDetailProvider()}>
+      {children}
+    </ReactContext.Provider>
+  );
+};
+
+export const useOrderDetail = () => {
+  const context = useContext(ReactContext);
+
+  if (!context) {
+    throw new Error("useOrderDetail must be used within a OrderDetailProvider");
+  }
+
+  return context;
+};
+
+export type TDomainCondition = [string, string, any];