1#@!#!123s

ALWAYS HENGHENG888 1#@!#!123s
: / var / www / chinawholesale-frontend-next / src / api /
Filename : cart-api.js
back
import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query'
import { queryConfig } from './query-config'
import { getCookie, setCookie } from '@/utils/manage-cookie'
import { apiPost, apiGet } from '@/utils/axiosInstance'
import { useMemo } from 'react'
import { SettingsContext, useMainContext } from '@/lib/SettingsProvider'
// import {useSearchParams} from "next/navigation";

export const setGetCartToken = (token = '', tokenKey = '_cart_token') => {
    let newValue = token
    if (token) {
        setCookie(tokenKey, token, 72000)
    } else {
        newValue = getCookie(tokenKey)
    }
    return newValue
}

export const useCartData = () => {
    const token = setGetCartToken()

    return useQuery({
        queryKey: ['cartData'],
        queryFn: async () => {
            const data = await apiGet(`cart${token ? `?token=${token}` : ''}`)
            const resData = data?.data || null
            if (resData?.cart_token) {
                setGetCartToken(resData?.cart_token)
            }
            return resData?.cart
        },
        // ...queryConfig,
    })
}

export const useCartContext = () => {
    const settingsData = useMainContext()

    return useMemo(() => settingsData?.usableCart || null, [settingsData?.usableCart])
}


export const useCart = () => {
    const token = setGetCartToken()

    const queryKey = ['cartData']
    const queryClient = useQueryClient()

    const mutationConfig = {
        onMutate: async () => {
            await queryClient.cancelQueries({ queryKey })
            const previousCart = queryClient.getQueryData(queryKey)
            return { previousCart }
        },
        onSuccess: async (resData, payloads, context) => {
            const newCart = resData?.data?.cart || null
            if (newCart?.cart_uid) {
                setGetCartToken(newCart?.cart_uid)
                queryClient.setQueryData(queryKey, newCart)
            } else {
                queryClient.setQueryData(queryKey, context.previousCart)
            }
        },
        onError: (err, newCart, context) => {
            // console.log(err, newCart)
            queryClient.setQueryData(queryKey, context.previousCart)
        },
        onSettled: () => {
            // queryClient.invalidateQueries({queryKey}).then()
        },
    }

    const addToCart = useMutation({
        ...mutationConfig,
        mutationKey: ['addToCart'],
        mutationFn: async (props = {}) => await apiPost(`cart/add`, { ...props, token: token }),
    })

    const updateCart = useMutation({
        ...mutationConfig,
        mutationKey: ['updateCart'],
        mutationFn: async (props = {}) => await apiPost(`cart/update`, { ...props, token: token }),
    })

    const preferShippingCategory = useMutation({
        ...mutationConfig,
        mutationKey: ['preferShippingCategory'],
        mutationFn: async (props = {}) => await apiPost(`cart/prefer-shipping-category`, {
            token, ...props,
        }),
    })

    const popupMessage = useMutation({
        ...mutationConfig,
        mutationKey: ['popupMessage'],
        mutationFn: async (props = {}) => await apiPost(`cart/read-popup`, {
            token,
            ...props,
        }),
    })

    const itemMarkAsCart = useMutation({
        ...mutationConfig,
        mutationKey: ['itemMarkAsCart'],
        mutationFn: async (props = {}) => await apiPost(`cart/mark-as-cart`, { token, ...props }),
    })

    const chooseShipping = useMutation({
        ...mutationConfig,
        mutationKey: ['chooseShipping'],
        mutationFn: async (props = {}) => await apiPost(`cart/choose-shipping`, {
            token, ...props,
        }),
    })


    const removeCart = useMutation({
        ...mutationConfig,
        mutationKey: ['removeCart'],
        mutationFn: async (props = {}) => await apiPost(`cart/remove`, {
            ...props,
            token: token,
            checkout: true,
        }),
    })

    const checkedUnchecked = useMutation({
        ...mutationConfig,
        mutationKey: ['checkedUnchecked'],
        mutationFn: async (props = {}) => await apiPost(`cart/checkbox`, {
            ...props,
            token: token,
            checkout: true,
        }),
    })


    const checkoutUpdate = useMutation({
        ...mutationConfig,
        mutationKey: ['checkoutUpdate'],
        mutationFn: async (props = {}) => await apiPost(`cart/update/checkout`, {
            ...props,
            token: token,
            checkout: true,
        }),
    })

    const cartCoupon = useMutation({
        ...mutationConfig,
        mutationKey: ['cartCoupon'],
        mutationFn: async (props = {}) => await apiPost(`cart/coupon`, {
            ...props,
            token,
            checkout: true,
        }),
    })

    const paymentMethod = useMutation({
        ...mutationConfig,
        mutationKey: ['paymentMethod'],
        mutationFn: async (props = {}) => await apiPost(`cart/payment-method`, {
            ...props,
            token: token,
            checkout: true,
        }),
    })


    return {
        addToCart,
        updateCart,
        preferShippingCategory,
        popupMessage,
        itemMarkAsCart,
        chooseShipping,
        removeCart,
        checkedUnchecked,
        checkoutUpdate,
        cartCoupon,
        paymentMethod,
    }
}


export const useConfirmOrder = () => {
    const queryClient = useQueryClient()
    const queryKey = ['cartData']

    return useMutation({
        mutationKey: ['confirmOrder'],
        mutationFn: async (payloads = {}) => {
            return await apiPost(`cart/place-order`, payloads)
        },
        onSettled: () => {
            queryClient.invalidateQueries({ queryKey }).then()
        },
    })
}


export const usePaymentInfoForPay = () => {
    return useQuery({
        queryKey: ['paymentInfoForPay'],
        queryFn: async () => {
            const data = await apiGet(`cart/bank-payment-info`)
            return data?.data?.banks || []
        },
    })
}

export const useCompleteBankPayment = () => {
    return useMutation({
        mutationKey: ['completeBankPayment'],
        mutationFn: async (payloads = {}) => {
            const data = await apiPost(`cart/confirm-bank-payment`, payloads)
            return data || {}
        },
    })
}

export const useCompleteWalletPayment = () => {
    return useMutation({
        mutationKey: ['completeWalletPayment'],
        mutationFn: async (payloads) => {
            const data = await apiPost(`cart/confirm-wallet-payment`, payloads)
            return data || {}
        },
    })
}


export const useShippingCategory = () => useQuery({
    queryKey: ['shippingCategory'],
    queryFn: async () => {
        const data = await apiGet(`wholesale/shipping-category`)
        return data?.categories || {}
    },
    staleTime: (1000 * 60 * 5),
})


export const useAliExpressDirectOrder = () => {
    const queryClient = useQueryClient()
    const queryKey = ['cartData']

    return useMutation({
        mutationKey: ['aliExpressDirectOrder'],
        mutationFn: async (payloads = {}) => {
            return await apiPost(`cart/submit-aliexpress-request`, payloads)
        },
        onSettled: () => {
            queryClient.invalidateQueries({ queryKey }).then()
        },
    })
}


const useCartMutationOperation = (mutateAsync) => {
    const queryClient = useQueryClient()
    return (props) =>
        mutateAsync(props, {
            onSettled: (cart) => {
                if (cart?.cart_uid) {
                    queryClient.setQueryData(['wholesaleCart', {}], cart)
                    queryClient.setQueryData(['wholesaleCart', { checkout: true }], cart)
                }
            },
        })
}


export const useWholesaleChooseShipping = () => {
    const token = setGetCartToken()
    const queryClient = useQueryClient()
    const { mutateAsync, isPending } = useMutation({
        mutationKey: ['wholesaleChooseShipping'],
        mutationFn: async (props) => {
            const data = await apiPost(`cart/choose-shipping`, {
                token,
                ...props,
            })
            return data?.cart || {}
        },
        onSuccess: async () => {
            await queryClient.invalidateQueries({ queryKey: ['cartData'] })
        },
    })

    const chooseShipping = useCartMutationOperation(mutateAsync)
    return {
        chooseShipping,
        isLoading: isPending,
    }
}

export const useWholesalePopupMessage = () => {
    const token = setGetCartToken()
    const queryClient = useQueryClient()
    const { mutateAsync, isPending } = useMutation({
        mutationKey: ['wholesalePopupMessage'],
        mutationFn: async (props) => {
            const data = await apiPost(`cart/read-popup`, {
                token,
                ...props,
            })
            return data?.cart || {}
        },
        onSuccess: async () => {
            await queryClient.invalidateQueries({ queryKey: ['cartData'] })
        },
    })

    return {
        popupMessage: mutateAsync,
        isLoading: isPending,
    }
}

export const useWholesaleShippingCategory = () => {

    return useQuery({
        queryKey: ['shippingCategory'],
        queryFn: async () => {
            const data = await apiGet(`shipping-category`)
            return data?.data || []
        },
        ...queryConfig,
    })
}