1#@!#!123s

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

export const has_permission = (permission_name) => {
    let access = window.localStorage.getItem('_access')
    access = access ? JSON.parse(access) : []
    let roles = window.localStorage.getItem('_roles')
    roles = roles ? JSON.parse(roles) : []
    if (roles?.length > 0) {
        if (roles?.includes('administrator')) {
            return true
        }
    }
    if (access?.length > 0) {
        return access?.includes(permission_name) || false
    }
    return false
}


const tokenInitialize = (data) => {
    const token = data?.data?.token || null
    if (token) {
        setCookie('_token', token, 18000)
    }
    return token
}

const authUserValidate = (resData) => {
    const data = resData?.data
    if (!data?.active) {
        removeCookies(['_token', '_cart_token'])
    }
    return data
}

export const useRawAuth = () => {
    return useQuery({
        queryKey: ['rawAuth'],
        queryFn: async () => {
            const data = await apiGet('user')
            return data?.data || null
        },
        ...queryConfig,
    })
}

export const useCustomer = () => {
    const { user, userIsLoading } = useMainContext()
    return { user, userIsLoading }
}

export const useCheckExistsUser = () => useMutation({
    mutationKey: ['checkExistsUser'],
    mutationFn: (payloads = {}) => {
        return apiPost(`check-exists-customer`, payloads)
    },
})

export const useAuthMutation = () => {
    const queryClient = useQueryClient()
    const { user, setCurrentUser } = useMainContext()

    const customerValidate = (resData) => {
        if (resData?.data?.active) {
            queryClient.setQueryData(['rawAuth'], (old) => {
                return {
                    ...old,
                    ...(resData?.data || []),
                }
            })
            setCurrentUser(resData?.data)
        } else {
            setCurrentUser(null)
        }
    }


    const loginSubmit = useMutation({
        mutationKey: ['loginSubmit'],
        mutationFn: async (payloads = {}) => {
            return await apiPost('login', payloads)
        },
        onSuccess: async (resData) => {
            if (resData?.data?.token) {
                setCookie('_token', resData?.data?.token)
            }
        },
    })

    const registerSubmit = useMutation({
        mutationKey: ['registerSubmit'],
        mutationFn: async (props) => {
            const data = await apiPost(`register-customer`, props)
            customerValidate(data)
            tokenInitialize(data)
            return data
        },
    })


    const updateProfile = useMutation({
        mutationKey: ['updateProfile'],
        mutationFn: async (props) => {
            const data = await apiPost(`update-profile`, props)
            customerValidate(data)
            authUserValidate(data)
            return data
        },
    })

    const forgotRequest = useMutation({
        mutationKey: ['forgotRequest'],
        mutationFn: async (props = {}) => {
            return await apiPost(`forgot-password`, props)
        },
    })

    const resetOtpVerify = useMutation({
        mutationKey: ['resetOtpVerify'],
        mutationFn: async (props = {}) => {
            return await apiPost(`reset-otp-verify`, props)
        },
    })

    const resetRequest = useMutation({
        mutationKey: ['resetRequest'],
        mutationFn: async (props) => {
            return await apiPost(`reset-password`, props)
        },
    })

    const authLogout = useMutation({
        mutationKey: ['authLogout'],
        mutationFn: async () => {
            // return new Promise((resolve) => {
            //     return resolve({ data: true })
            // })
            await apiPost('logout')
        },
        onSuccess: () => {
            sendRequest('POST', '/api/logout')
                .then((resData) => {
                    if (resData?.data?.status) {
                        // console.log({ resData })
                        deleteAllCookies()
                        customerValidate(null)
                        window.location.replace('/login')
                    }
                })
        },
    })

    return {
        user,
        registerSubmit,
        loginSubmit,
        updateProfile,
        authLogout,
        forgotRequest,
        resetOtpVerify,
        resetRequest,
    }
}

export const useCheckConfirmation = (props) =>
    useQuery({
        queryKey: ['checkConfirmation'],
        queryFn: async () => {
            return await apiPost(`check-user-confirmation`, props)
        },
        ...queryConfig,

    })

export const useCheckOtpCode = () =>
    useMutation({
        mutationKey: ['checkOtpCode'],
        mutationFn: async (props = {}) => {
            return await apiPost(`verify-otp`, props)
        },
        ...queryConfig,
    })

export const useResetTokenValidate = (token) =>
    useQuery({
        queryKey: ['resetTokenValidate', token],
        queryFn: async () => {
            return await apiPost(`reset-token-validate`, { token })
        },
        ...queryConfig,

    })


export const useResendOtpForLogin = () =>
    useMutation({
        mutationKey: ['resendOtpForLogin'],
        mutationFn: async (props = {}) => {
            return await apiPost(`resend-otp`, props)
        },
    })

export const submitForOtpForLogin = async (formData) => {
    return await apiPost(`submit-otp`, formData)
}