CFE-1 create project from the tamplate project and config project

src/lib/app/contexts/language.jsx

@@ -0,0 +1,99 @@
+import {FA_DATATABLE_LOCALIZATION} from "&/locales/fa/datatable";
+import {useRouter} from "next/router";
+import {createContext, useEffect, useState} from "react";
+import useUser from "../hooks/useUser";
+
+export const LanguageContext = createContext();
+
+export const LanguageProvider = ({children}) => {
+    const router = useRouter();
+    const languageList = [
+        {
+            key: "fa",
+            dir: "rtl",
+            name: "فارسی",
+            fontFamily: `IRANSans, sans-serif`,
+            tableLocalization: FA_DATATABLE_LOCALIZATION,
+        }
+    ];
+    const {user, userChangedLanguage, changeLanguageState} = useUser();
+    const [languageIsReady, setLanguageIsReady] = useState(false);
+    const [languageApp, setLanguageApp] = useState();
+    const [directionApp, setDirectionApp] = useState(
+        process.env.NEXT_PUBLIC_DEFAULT_DIRECTION
+    );
+
+    useEffect(() => {
+        const lang = localStorage.getItem("_language");
+
+        if (!lang && !languageApp) {
+            setLanguageApp(process.env.NEXT_PUBLIC_DEFAULT_LANGUAGE);
+        } else if (lang) {
+            setLanguageApp(lang);
+        }
+    }, []);
+
+    useEffect(() => {
+        if (!languageApp) return;
+
+        const lang = localStorage.getItem("_language");
+
+        if (!lang) {
+            localStorage.setItem("_language", languageApp);
+        } else {
+            if (languageApp != lang) {
+                localStorage.setItem("_language", languageApp);
+            }
+        }
+    }, [languageApp]);
+
+    useEffect(() => {
+        if (!router.isReady) return;
+        if (user.user_language) {
+            if (user.user_language != languageApp) {
+                setLanguageApp(user.user_language);
+                return;
+            }
+        }
+
+        if (languageApp != router.locale) {
+            router.replace(
+                {pathname: router.pathname, query: router.query},
+                router.asPath,
+                {
+                    locale: languageApp,
+                }
+            );
+            return;
+        }
+        for (const lang of languageList) {
+            if (languageApp != lang.key) continue;
+            setDirectionApp(lang.dir);
+            document.dir = lang.dir;
+        }
+
+        const timer = setTimeout(() => {
+            changeLanguageState(false);
+            setLanguageIsReady(true);
+        }, 1000);
+
+        return () => {
+            clearTimeout(timer);
+        };
+    }, [router.locale, router.isReady, userChangedLanguage, languageApp]);
+
+    return (
+        <LanguageContext.Provider
+            value={{
+                languageApp,
+                setLanguageApp,
+                directionApp,
+                languageIsReady,
+                setLanguageIsReady,
+                languageList,
+            }}
+        >
+            {children}
+        </LanguageContext.Provider>
+    );
+};

src/lib/app/contexts/loading.jsx

@@ -0,0 +1,14 @@
+import LoadingHardPage from "@/core/components/LoadingHardPage";
+import {createContext, useState} from "react";
+
+export const LoadingContext = createContext();
+
+export const LoadingProvider = ({children}) => {
+    const [loadingPage, setLoadingPage] = useState(false);
+    return (
+        <LoadingContext.Provider value={{loadingPage, setLoadingPage}}>
+            <LoadingHardPage loading={loadingPage}/>
+            {children}
+        </LoadingContext.Provider>
+    );
+};

src/lib/app/contexts/user.jsx

@@ -0,0 +1,132 @@
+import {GET_USER_ROUTE} from "@/core/data/apiRoutes";
+import axios from "axios";
+import {createContext, useCallback, useEffect, useReducer} from "react";
+import {errorRequest, errorResponse, errorSetting} from "@/core/utils/errorHandler";
+
+const initialUser = {
+    isAuth: false,
+    userChangedLanguage: false,
+    token: null,
+    user: {},
+};
+
+const reducer = (state, action) => {
+    switch (action.type) {
+        case "CLEAR_USER":
+            return {...state, user: {}};
+        case "CHANGE_USER":
+            return {...state, user: action.user};
+        case "CHANGE_USER_LANGUAGE":
+            return {
+                ...state,
+                user: {...state.user, user_language: action.language},
+            };
+        case "CHANGE_AUTH_STATE":
+            return {...state, isAuth: action.isAuth};
+        case "CHANGE_LANGUAGE_STATE":
+            return {...state, userChangedLanguage: action.userChangedLanguage};
+        case "CLEAR_TOKEN":
+            localStorage.removeItem("_token");
+            return {...state, token: null};
+        case "SET_TOKEN":
+            localStorage.setItem("_token", action.token);
+            return {...state, token: action.token};
+        default:
+            return state;
+    }
+};
+
+export const UserContext = createContext();
+
+export const UserProvider = ({children}) => {
+    const [state, dispatch] = useReducer(reducer, initialUser);
+
+    const clearUser = useCallback(() => {
+        dispatch({type: "CLEAR_USER"});
+    }, []);
+
+    const changeUser = useCallback((user) => {
+        dispatch({type: "CHANGE_USER", user});
+    }, []);
+
+    const changeUserLanguage = useCallback(/* use in multi language app */);
+
+    const changeAuthState = useCallback((isAuth) => {
+        dispatch({type: "CHANGE_AUTH_STATE", isAuth});
+    }, []);
+
+    const changeLanguageState = useCallback((userChangedLanguage) => {
+        dispatch({type: "CHANGE_LANGUAGE_STATE", userChangedLanguage});
+    }, []);
+
+    const clearToken = useCallback(() => {
+        dispatch({type: "CLEAR_TOKEN"});
+    }, []);
+
+    const setToken = useCallback((token) => {
+        dispatch({type: "SET_TOKEN", token});
+    }, []);
+
+    const getUser = useCallback(
+        (callback = () => {
+        }) => {
+            axios
+                .get(GET_USER_ROUTE, {
+                    headers: {authorization: `Bearer ${state.token}`},
+                })
+                .then(({data}) => {
+                    if (typeof callback === "function") callback(data);
+                })
+                .catch(error => {
+                    if (error.response) {
+                        errorResponse(error.response, clearToken, null, false)
+                    } else if (error.request) {
+                        errorRequest(null, false)
+                    } else {
+                        errorSetting(null, false)
+                    }
+                })
+        },
+        [state.token]
+    );
+
+    useEffect(() => {
+        const localToken = localStorage.getItem("_token");
+        if (localToken) dispatch({type: "SET_TOKEN", token: localToken});
+    }, []);
+
+    useEffect(() => {
+        if (!state.token) {
+            clearUser();
+            changeAuthState(false);
+            changeLanguageState(false);
+            return;
+        }
+        getUser((data) => {
+            changeUser(data);
+            changeAuthState(true);
+            changeLanguageState(true);
+        });
+    }, [state.token]);
+
+    return (
+        <UserContext.Provider
+            value={{
+                isAuth: state.isAuth,
+                userChangedLanguage: state.userChangedLanguage,
+                token: state.token,
+                user: state.user,
+                getUser,
+                clearUser,
+                changeUser,
+                changeUserLanguage,
+                changeAuthState,
+                changeLanguageState,
+                clearToken,
+                setToken,
+            }}
+        >
+            {children}
+        </UserContext.Provider>
+    );
+};

src/lib/app/hooks/useDirection.jsx

@@ -0,0 +1,10 @@
+import {useContext} from "react";
+import {LanguageContext} from "../contexts/language";
+
+const useDirection = () => {
+    const {directionApp} = useContext(LanguageContext);
+
+    return {directionApp};
+};
+
+export default useDirection;

src/lib/app/hooks/useLanguage.jsx

@@ -0,0 +1,28 @@
+import {useContext} from "react";
+import {LanguageContext} from "../contexts/language";
+import useUser from "./useUser";
+
+const useLanguage = () => {
+    const {isAuth, changeUserLanguage} = useUser();
+    const {
+        languageApp,
+        setLanguageApp,
+        languageIsReady,
+        setLanguageIsReady,
+        languageList,
+    } = useContext(LanguageContext);
+
+    const changeLanguage = (lang) => {
+        if (lang == languageApp) return;
+
+        setLanguageIsReady(false);
+        setLanguageApp(lang);
+        if (isAuth) {
+            changeUserLanguage(lang);
+        }
+    };
+
+    return {languageApp, changeLanguage, languageIsReady, languageList};
+};
+
+export default useLanguage;

src/lib/app/hooks/useLoading.jsx

@@ -0,0 +1,10 @@
+import {useContext} from "react";
+import {LoadingContext} from "../contexts/loading";
+
+const useLoading = () => {
+    const {setLoadingPage} = useContext(LoadingContext);
+
+    return {setLoadingPage};
+};
+
+export default useLoading;

src/lib/app/hooks/useNetwork.jsx

@@ -0,0 +1,58 @@
+import {useEffect, useState} from "react";
+
+function getNetworkConnection() {
+    return (
+        navigator.connection ||
+        navigator.mozConnection ||
+        navigator.webkitConnection ||
+        null
+    );
+}
+
+function getNetworkConnectionInfo() {
+    const connection = getNetworkConnection();
+    if (!connection) {
+        return {};
+    }
+    return {
+        rtt: connection.rtt,
+        type: connection.type,
+        saveData: connection.saveData,
+        downLink: connection.downLink,
+        downLinkMax: connection.downLinkMax,
+        effectiveType: connection.effectiveType,
+    };
+}
+
+function useNetwork() {
+    const [state, setState] = useState(() => {
+        return {
+            online: navigator.onLine,
+        };
+    });
+    useEffect(() => {
+        const handleOnline = () => {
+            setState((prevState) => ({
+                ...prevState,
+                online: true,
+            }));
+        };
+        const handleOffline = () => {
+            setState((prevState) => ({
+                ...prevState,
+                online: false,
+            }));
+        };
+
+        window.addEventListener("online", handleOnline);
+        window.addEventListener("offline", handleOffline);
+        return () => {
+            window.removeEventListener("online", handleOnline);
+            window.removeEventListener("offline", handleOffline);
+        };
+    }, []);
+    
+    return state;
+}
+
+export default useNetwork;

src/lib/app/hooks/useNotification.jsx

@@ -0,0 +1,23 @@
+import useSWR from 'swr'
+import {GET_SIDEBAR_NOTIFICATION} from "@/core/data/apiRoutes";
+import useRequest from "@/lib/app/hooks/useRequest";
+
+const useNotification = () => {
+    const requestServer = useRequest({auth: true, notification: false})
+
+    //swr config
+    const fetcher = (...args) => {
+        return requestServer(args, 'get').then((response) => {
+            return response.data.data;
+        }).catch(() => {
+        })
+    };
+
+    const {data, mutate} = useSWR(GET_SIDEBAR_NOTIFICATION, fetcher)
+    const notification_count = data
+    //swr config
+
+    // render data
+    return {notification_count, update_notification: mutate}
+}
+export default useNotification

src/lib/app/hooks/useRequest.jsx

@@ -0,0 +1,66 @@
+import axios from "axios";
+import {successRequest} from "@/core/utils/succesHandler";
+import PendingNotification from "@/core/components/notifications/PendingNotification";
+import {useTranslations} from "next-intl";
+import useUser from "@/lib/app/hooks/useUser";
+import {errorRequest, errorResponse, errorSetting} from "@/core/utils/errorHandler";
+import useNetwork from "@/lib/app/hooks/useNetwork";
+
+const defaultOptions = {
+    auth: false, data: {}, requestOptions: {
+        headers: {}
+    }, notification: true, pending: true, success: {
+        notification: {
+            show: true,
+        },
+    }, failed: {
+        notification: {
+            show: true,
+        },
+    },
+}
+const useRequest = (initOptions) => {
+    const network = useNetwork()
+    const t = useTranslations()
+    const {token, clearToken} = useUser()
+    let _options = {...defaultOptions, ...initOptions}
+
+    function requestServer(url = '', method = 'get', options) {
+        _options = {..._options, ...options}
+        if (_options.auth) _options = {
+            ..._options, requestOptions: {
+                ..._options.requestOptions,
+                headers: {..._options.requestOptions.headers, authorization: `Bearer ${token}`}
+            }
+        }
+
+        return new Promise((resolve, reject) => {
+            if (!network.online) {
+                reject()
+                return
+            }
+            if (_options.notification && _options.failed.notification.show && _options.pending) PendingNotification(t)
+            axios({
+                url: url, method: method, data: _options.data, ..._options.requestOptions
+            })
+                .then(response => {
+                    successRequest(response, t, _options)
+                    resolve(response)
+                })
+                .catch(error => {
+                    if (error.response) {
+                        errorResponse(error.response, clearToken, t, _options.notification && _options.failed.notification.show)
+                    } else if (error.request) {
+                        errorRequest(t, _options.notification && _options.failed.notification.show)
+                    } else {
+                        errorSetting(t, _options.notification && _options.failed.notification.show)
+                    }
+                    reject(error)
+                })
+        });
+    }
+
+    return requestServer
+}
+
+export default useRequest

src/lib/app/hooks/useUser.jsx

@@ -0,0 +1,34 @@
+import {useContext} from "react";
+import {UserContext} from "../contexts/user";
+
+const useUser = () => {
+    const {
+        isAuth,
+        userChangedLanguage,
+        token,
+        user,
+        getUser,
+        clearUser,
+        changeUser,
+        changeAuthState,
+        changeLanguageState,
+        clearToken,
+        setToken,
+    } = useContext(UserContext);
+
+    return {
+        isAuth,
+        userChangedLanguage,
+        token,
+        user,
+        getUser,
+        clearUser,
+        changeUser,
+        changeAuthState,
+        changeLanguageState,
+        clearToken,
+        setToken,
+    };
+};
+
+export default useUser;