oneticket-sdk-vi 1.0.0

package/src/screens/metro/TransportationSelectionScreen.tsx

@@ -0,0 +1,102 @@
+// import React, { useState } from 'react';
+// import { Box, Button, VStack } from 'native-base';
+// import TransportationCard from '../../components/common/Cards/TransportationCard';
+// import Sidebar from '../../components/Sidebar/Sidebar';
+// import { useNavigation } from '@react-navigation/native';
+// import HamburgerIcon from '../../assets/icons/HamburgerIcon';
+// import BellIcon from '../../assets/icons/BellIcon';
+// import { AuthScreens, AuthStackNavigationProp } from '../../navigation/AuthStack';
+// import Header from '../../components/common/Header/Header';
+// import { MetroScreens } from '../../navigation/metro/MetroStack';
+// import { MetroTabScreens } from '../../navigation/metro/MetroTabs';
+// import { RideHailingScreens } from '../../navigation/RideHailing/RideHailingStack';
+// import { RideHailingBottomTabScreens } from '../../navigation/RideHailing/RideHailingBottomTabs';
+// import { RideHailingHomeWithBottomTabsScreens } from '../../navigation/RideHailing/RideHailingHomeWithBottomTabsStack';
+// import { MetroWithTabsScreens } from '../../navigation/metro/MetroWithTabsStack';
+
+// export default function TransportationSelectionScreen() {
+//     const { navigate } = useNavigation<AuthStackNavigationProp>();
+//     const [menuVisible, setMenuVisible] = useState(false);
+
+//     const transportationOptions = [
+//         {
+//             label: 'Metro',
+//             image: require('../../assets/images/metro.png'),
+//             onPress: () => navigate(AuthScreens.MetroStack, {
+//                 screen: MetroScreens.MetroTabs,
+//                 params: {
+//                     screen: MetroTabScreens.MetroWithTabsStack,
+//                     params: {
+//                         screen: MetroWithTabsScreens.SelectStations
+//                     }
+//                 }
+//             }),
+//         },
+//         {
+//             label: 'Bus',
+//             image: require('../../assets/images/bus.png'),
+//             onPress: () => { },
+//         },
+//         {
+//             label: 'Ride Hailing',
+//             image: require('../../assets/images/car.png'),
+//             onPress: () => navigate(AuthScreens.RideHailingStack, {
+//                 screen: RideHailingScreens.RideHailingBottomTabs,
+//                 params: {
+//                     screen: RideHailingBottomTabScreens.RideHailingHomeWithBottomTabsStack,
+//                     params: {
+//                         screen: RideHailingHomeWithBottomTabsScreens.MapScreen
+//                     }
+//                 }
+//             }),
+//         },
+//     ];
+
+//     const handleMenuToggle = () => {
+//         setMenuVisible(!menuVisible);
+//     };
+
+//     const handleCloseSidebar = () => {
+//         setMenuVisible(false);
+//     };
+
+//     return (
+//         <Box flex={1} bg={'white'}>
+//             {/* Sidebar */}
+//             {menuVisible && (
+//                 // <Sidebar visible={menuVisible} onClose={handleCloseSidebar} />
+//             )}
+
+//             <Header
+//                 leftComponent={
+//                     <Button variant="ghost" onPress={handleMenuToggle}>
+//                         <HamburgerIcon size={20} />
+//                     </Button>
+//                 }
+//                 title='Select Transportation'
+//                 rightComponent={
+//                     <Button variant="ghost">
+//                         <BellIcon size={20} />
+//                         {/* <Icon as={Ionicons} name="notifications-outline" size="lg" /> */}
+//                     </Button>
+//                 }
+//             />
+
+//             {/* Header */}
+//             <Box py={4} px={6}>
+//                 {/* Transportation Options */}
+//                 <VStack space={5} mt={5}>
+//                     {transportationOptions.map((option, index) => (
+//                         <TransportationCard
+//                             key={index}
+//                             label={option.label}
+//                             image={option.image}
+//                             onPress={option.onPress}
+//                             imageSize={150} // Set the image size in pixels
+//                         />
+//                     ))}
+//                 </VStack>
+//             </Box>
+//         </Box>
+//     );
+// }

package/src/services/apiCall.ts

@@ -0,0 +1,29 @@
+import axios, { AxiosError } from "axios";
+
+export const apiCall = async <R, D = {}>(method: 'get' | 'post' | 'patch' | 'put' | 'delete', url: string, data?: D, showToast: boolean = true): Promise<R> => {
+    try {
+        const response = await axios({
+            method,
+            url,
+            data,
+            withCredentials: true
+        })
+        return response.data;
+    } catch (err) {
+        if (err instanceof AxiosError && err.response) {
+            if (err.response.data.status === 'success' || err.response.data.status === 'error') {
+                return err.response.data;
+            } else {
+                return {
+                    status: 'error',
+                    message: "No Response From Server"
+                } as R;
+            }
+        } else {
+            return {
+                status: 'error',
+                message: "No Response From Server"
+            } as R;
+        }
+    }
+}

package/src/services/apiRoutes.ts

@@ -0,0 +1,74 @@
+// const basePath = `http://localhost:5001`;
+export const basePath: any = `https://demo-products.sequelstring.com/dmrc-buyer-dashboard`;
+// export const basePath = `https://oneticket-prod-dashboard.sequelstring.com`;
+
+// AUTH
+export const signUpOtpSendApiPath = `${basePath}/auth/otpToRegisterUser`;
+export const registerUserApiPath = `${basePath}/auth/registerUser`;
+export const loginOtpSendApiPath = `${basePath}/auth/otpForLoginUser`;
+export const loginUserApiPath = `${basePath}/auth/loginUser`;
+export const loggedInUserApiPath = `${basePath}/auth/loggedInUser`;
+export const logoutApiPath = `${basePath}/auth/logout`;
+export const deleteUserApiPath = `${basePath}/auth/deleteUser`;
+export const sdkLoginApiPath = `${basePath}/auth/sdkLogin`;
+
+// USER
+export const updateUserApiPath = `${basePath}/user/update`;
+
+// SESSION
+export const startSessionApiPath = `${basePath}/session/start`;
+export const endSessionApiPath = `${basePath}/session/end`;
+
+// <------------------------------------- CITY ----------------------------->
+export const allCitiesApiPath = `${basePath}/metro/allCitiesApp`;
+export const allCityLinesApiPath = `${basePath}/metro/allCityLinesApp`;
+export const selectCityApiPath = `${basePath}/metro/selectCity`;
+export const currectCityApiPath = `${basePath}/metro/currentCity`;
+
+
+// <------------------------------------- METRO ---------------------------->
+// PROVIDERS 
+export const requestMetroProvidersApiPath = `${basePath}/metro/requestProviders`;
+export const getMetroProvidersApiPath = `${basePath}/metro/getProviders`;
+
+// STATIONS
+export const getMetroStationsApiPath = `${basePath}/metro/getAllStationsApp`;
+export const findNearestStationApiPath = `${basePath}/metro/findNearestStation`;
+
+// FARE
+export const getMetroFaresApiPath = `${basePath}/metro/getFares`;
+
+// INIT TICKET
+export const initMetroTicketV2ApiPath = `${basePath}/metro/initTicketV2`;
+
+// CONFIRM TICKET
+export const confirmMetroTicketApiPath = `${basePath}/metro/confirmTicket`;
+
+// <----------------------------- TRANSACTIONS ---------------------------------->
+export const getAllTransactionsApiPath = `${basePath}/transactions`;
+export const getRecentTransactionsApiPath = `${basePath}/transactions/recent`;
+
+// ------------------------------ PAYMENTS -------------------------------------->
+export const createPaymentApiPath = `${basePath}/payment/create`;
+export const verifyPaymentApiPath = `${basePath}/payment/verify`;
+export const errorPaymentApiPath = `${basePath}/payment/error`;
+
+// <---------------------------- STATUS --------------------------------------->
+export const getMetroTicketStatusApiPath = `${basePath}/metro/getStatus`;
+export const isQrActiveApiPath = `${basePath}/metro/isQrActive`;
+
+// <--------------------------- ISSUES --------------------------------------->
+export const raiseMetroTicketIssueApiPath = `${basePath}/issues/raiseIssue`;
+export const getAllMetroIssuesApiPath = `${basePath}/issues/getAllIssues`;
+export const getMetroIssueDetailsApiPath = `${basePath}/issues/getIssueDetails`;
+export const getChatApiPath = `${basePath}/issues/getChat`;
+export const sendMessageApiPath = `${basePath}/issues/sendMessage`;
+export const closeIssueApiPath = `${basePath}/issues/closeIssueApp`;
+
+// <--------------------------- CANCEL TICKET -------------------------------->
+export const softCancelMetroTicketApiPath = `${basePath}/metro/softCancel`;
+export const hardCancelMetroTicketApiPath = `${basePath}/metro/hardCancel`;
+
+// <--------------------------- GET VERSION -------------------------------->
+export const getAppVersionApiPath = `${basePath}/app-version/latest-version`;
+

package/src/services/apis/appVersion/apis.ts

@@ -0,0 +1,9 @@
+import { apiCall } from "../../apiCall";
+import { getAppVersionApiPath } from "../../apiRoutes";
+import { GetAppVersionApiPayload, GetAppVersionApiResponse } from "./types";
+
+export const getAppVersionApi = async (payload: GetAppVersionApiPayload): Promise<GetAppVersionApiResponse> => {
+    const { platform } = payload;
+    const data = await apiCall<GetAppVersionApiResponse>("post", `${getAppVersionApiPath}/${platform}`);
+    return data;
+};

package/src/services/apis/appVersion/hooks.ts

@@ -0,0 +1,17 @@
+import { useMutation, useQuery } from "@tanstack/react-query"
+import { GetAppVersionApiPayload, GetAppVersionApiResponse } from "./types"
+import { getAppVersionApi } from "./apis"
+
+// GET APP VERSION
+export const useMutateGetAppVersion = (onSuccess: (data: GetAppVersionApiResponse) => void, onError: (data: GetAppVersionApiResponse) => void) => {
+    return useMutation({
+        mutationFn: (payload: GetAppVersionApiPayload) => getAppVersionApi(payload),
+        onSuccess: (data) => {
+            if (data.status === 'success') {
+                onSuccess(data)
+            } else {
+                onError(data)
+            }
+        }
+    })
+}

package/src/services/apis/appVersion/types.ts

@@ -0,0 +1,19 @@
+// GET APP VERSION PAYLOAD
+export type GetAppVersionApiPayload = {
+    platform: string;
+}
+
+// GET APP VERSION RESPONSE
+export type GetAppVersionApiResponse = {
+    status: 'success' | 'error';
+    message: string;
+    versionInfo: {
+        platform: string;
+        latestVersion: string;
+        forceUpdate: boolean;
+        createdAt: string;
+        updatedAt: string;
+    }
+}
+
+

package/src/services/apis/auth/apis.ts

@@ -0,0 +1,50 @@
+import { apiCall } from "../../apiCall";
+import { deleteUserApiPath, loggedInUserApiPath, loginOtpSendApiPath, loginUserApiPath, logoutApiPath, registerUserApiPath, sdkLoginApiPath, signUpOtpSendApiPath } from "../../apiRoutes";
+import { DeleteUserApiResponse, LoggedInUserApiResponse, LoginOtpSendApiPayload, LoginOtpSendApiResponse, LoginUserApiPayload, LoginUserApiResponse, RegisterUserApiPayload, RegisterUserApiResponse, SdkLoginApiPayload, SdkLoginApiResponse, SignUpOtpSendApiPayload, SignUpOtpSendApiResponse } from "./types";
+
+// SIGN UP OTP SEND
+export const signUpOtpSendApi = async (payload: SignUpOtpSendApiPayload): Promise<SignUpOtpSendApiResponse> => {
+    const data = await apiCall<SignUpOtpSendApiResponse, SignUpOtpSendApiPayload>("post", `${signUpOtpSendApiPath}`, payload);
+    return data;
+}
+// REGISTER USER
+export const registerUserApi = async (payload: RegisterUserApiPayload): Promise<RegisterUserApiResponse> => {
+    const data = await apiCall<RegisterUserApiResponse, RegisterUserApiPayload>("post", `${registerUserApiPath}`, payload);
+    return data;
+}
+
+// LOGIN OTP SEND
+export const loginOtpSendApi = async (payload: LoginOtpSendApiPayload): Promise<LoginOtpSendApiResponse> => {
+    const data = await apiCall<LoginOtpSendApiResponse, LoginOtpSendApiPayload>("post", `${loginOtpSendApiPath}`, payload);
+    return data;
+}
+
+// LOGIN USER
+export const loginUserApi = async (payload: LoginUserApiPayload): Promise<LoginUserApiResponse> => {
+    const data = await apiCall<LoginUserApiResponse, LoginUserApiPayload>("post", `${loginUserApiPath}`, payload);
+    return data;
+}
+
+// SDK LOGIN
+export const sdkLoginApi = async (payload: SdkLoginApiPayload): Promise<SdkLoginApiResponse> => {
+    const data = await apiCall<SdkLoginApiResponse, SdkLoginApiPayload>("post", `${sdkLoginApiPath}`, payload);
+    return data;
+}
+
+// LOGGED IN USER
+export const loggedInUserApi = async (): Promise<LoggedInUserApiResponse> => {
+    const data = await apiCall<LoggedInUserApiResponse>("post", `${loggedInUserApiPath}`);
+    return data;
+}
+
+// LOGGED IN USER
+export const logoutApi = async (): Promise<LoggedInUserApiResponse> => {
+    const data = await apiCall<LoggedInUserApiResponse>("post", `${logoutApiPath}`);
+    return data;
+}
+
+// DELETE USER
+export const deleteUserApi = async (): Promise<DeleteUserApiResponse> => {
+    const data = await apiCall<DeleteUserApiResponse>("post", `${deleteUserApiPath}`);
+    return data;
+}

package/src/services/apis/auth/hooks.ts

@@ -0,0 +1,173 @@
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { DeleteUserApiResponse, LoginOtpSendApiPayload, LoginOtpSendApiResponse, LoginUserApiPayload, LoginUserApiResponse, LogoutApiResponse, RegisterUserApiPayload, RegisterUserApiResponse, SdkLoginApiPayload, SdkLoginApiResponse, SignUpOtpSendApiPayload, SignUpOtpSendApiResponse } from "./types";
+import { deleteUserApi, loggedInUserApi, loginOtpSendApi, loginUserApi, logoutApi, registerUserApi, sdkLoginApi, signUpOtpSendApi } from "./apis";
+import Toast from "react-native-toast-message";
+
+// SIGN UP OTP SEND
+export const useMutateSignUpOtpSend = (response: (data: SignUpOtpSendApiResponse) => void) => {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (payload: SignUpOtpSendApiPayload) => signUpOtpSendApi(payload),
+        onSuccess: data => {
+            response(data);
+            if (data.status === 'success') {
+                queryClient.invalidateQueries({ queryKey: [""] });
+                Toast.show({
+                    type: "success",
+                    text1: data.message
+                });
+            } else {
+                Toast.show({
+                    type: "error",
+                    text1: data.message
+                });
+            }
+        }
+    })
+}
+
+// REGISTER USER
+export const useMutateRegisterUser = (response: (data: RegisterUserApiResponse) => void) => {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (payload: RegisterUserApiPayload) => registerUserApi(payload),
+        onSuccess: data => {
+            response(data);
+            if (data.status === 'success') {
+                queryClient.invalidateQueries({ queryKey: ["loggedInUserApi"] });
+                Toast.show({
+                    type: "success",
+                    text1: data.message
+                });
+            } else {
+                Toast.show({
+                    type: "error",
+                    text1: data.message
+                });
+            }
+        }
+    })
+}
+
+// LOGIN OTP SEND
+export const useMutateLoginOtpSend = (response: (data: LoginOtpSendApiResponse) => void) => {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (payload: LoginOtpSendApiPayload) => loginOtpSendApi(payload),
+        onSuccess: data => {
+            response(data);
+            if (data.status === 'success') {
+                queryClient.invalidateQueries({ queryKey: [""] });
+                Toast.show({
+                    type: "success",
+                    text1: data.message
+                });
+            } else {
+                Toast.show({
+                    type: "error",
+                    text1: data.message
+                });
+            }
+        }
+    })
+}
+
+// LOGIN USER
+export const useMutateLoginUser = (response: (data: LoginUserApiResponse) => void) => {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (payload: LoginUserApiPayload) => loginUserApi(payload),
+        onSuccess: data => {
+            response(data);
+            if (data.status === 'success') {
+                queryClient.invalidateQueries({ queryKey: ["loggedInUserApi"] });
+                Toast.show({
+                    type: "success",
+                    text1: data.message
+                });
+            } else {
+                Toast.show({
+                    type: "error",
+                    text1: data.message
+                });
+            }
+        }
+    })
+}
+
+// SDK LOGIN
+export const useMutateSdkLogin = (response: (data: SdkLoginApiResponse) => void) => {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (payload: SdkLoginApiPayload) => sdkLoginApi(payload),
+        onSuccess: data => {
+            response(data);
+            if (data.status === 'success') {
+                queryClient.invalidateQueries({ queryKey: ["loggedInUserApi"] });
+                Toast.show({
+                    type: "success",
+                    text1: data.message
+                });
+            } else {
+                Toast.show({
+                    type: "error",
+                    text1: data.message
+                });
+            }
+        }
+    })
+}
+
+// LOGIN USER
+export const useFetchLoggedInUser = () => {
+    return useQuery({
+        queryKey: ["loggedInUserApi"],
+        queryFn: loggedInUserApi
+    })
+}
+
+// LOGOUT
+export const useMutatelogout = (response: (data: LogoutApiResponse) => void) => {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: () => logoutApi(),
+        onSuccess: data => {
+            response(data);
+            if (data.status === 'success') {
+                queryClient.invalidateQueries({ queryKey: ["loggedInUserApi"] });
+                Toast.show({
+                    type: "success",
+                    text1: data.message
+                });
+            } else {
+                Toast.show({
+                    type: "error",
+                    text1: data.message
+                });
+            }
+        }
+    })
+}
+
+// DELETE USER
+export const useMutateDeleteUser = (response: (data: DeleteUserApiResponse) => void) => {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: () => deleteUserApi(),
+        onSuccess: data => {
+            response(data);
+            if (data.status === 'success') {
+                queryClient.invalidateQueries({ queryKey: ["loggedInUserApi"] });
+                Toast.show({
+                    type: "success",
+                    text1: data.message
+                });
+            } else {
+                Toast.show({
+                    type: "error",
+                    text1: data.message
+                });
+            }
+        }
+    })
+}

package/src/services/apis/auth/types.ts

@@ -0,0 +1,100 @@
+// SIGN UP OTP SEND
+export type SignUpOtpSendApiPayload = {
+  moNumber: number;
+};
+export type SignUpOtpSendApiResponse = {
+  status: 'success' | 'error';
+  message: string;
+  tokenId: string;
+};
+
+// REGISTER USER
+export type RegisterUserApiPayload = {
+  moNumber: number;
+  otp: number;
+};
+export type RegisterUserApiResponse = {
+  status: 'success' | 'error';
+  message: string;
+};
+
+// LOG IN OTP SEND
+export type LoginOtpSendApiPayload = {
+  moNumber: number;
+};
+export type LoginOtpSendApiResponse = {
+  status: 'success' | 'error';
+  message: string;
+  tokenId: string;
+};
+
+// LOGIN USER
+export type LoginUserApiPayload = {
+  moNumber: number;
+  otp: number;
+};
+export type LoginUserApiResponse =
+  | {
+    status: 'success';
+    message: string;
+    user: {
+      firstSetup: boolean;
+    };
+  }
+  | {
+    status: 'error';
+    message: string;
+  };
+
+// SDK LOGIN
+export type SdkLoginApiPayload = {
+  name: string;
+  sdkKey: string;
+  moNumber: number;
+  email?: string;
+
+};
+export type SdkLoginApiResponse =
+  | {
+    status: 'success';
+    message: string;
+    user: {
+      firstSetup: boolean;
+    };
+  }
+  | {
+    status: 'error';
+    message: string;
+  };
+
+// LOGGED IN USER
+export type LoggedInUserApiResponse = {
+  status: 'success' | 'error';
+  message: string;
+  user: {
+    _id: string;
+    moNumber: number;
+    cityCode: string;
+    role: string;
+    permission: any[];
+    firstSetup: boolean;
+    username: string;
+    is_active: boolean;
+    createdAt: string;
+    updatedAt: string;
+    name?: string;
+    gender: string;
+  };
+};
+
+// LOGOUT
+export type LogoutApiResponse = {
+  status: 'success' | 'error';
+  message: string;
+};
+
+// DELETE USER
+export type DeleteUserApiResponse = {
+  status: 'success' | 'error';
+  message: string;
+};

package/src/services/apis/city/apis.ts

@@ -0,0 +1,28 @@
+import { convertToQueryString } from "../../../utils/queryString";
+import { apiCall } from "../../apiCall";
+import { allCitiesApiPath, allCityLinesApiPath, currectCityApiPath, selectCityApiPath } from "../../apiRoutes";
+import { AllCitiesApiPayload, AllCitiesApiResponse, AllCityLinesApiPayload, AllCityLinesApiResponse, CurrectCityApiPayload, CurrectCityApiResponse, SelectCityApiPayload, SelectCityApiResponse } from "./types";
+
+// ALL CITIES
+export const allCitiesApi = async (payload: AllCitiesApiPayload): Promise<AllCitiesApiResponse> => {
+    const data = await apiCall<AllCitiesApiResponse>("get", `${allCitiesApiPath}?${convertToQueryString(payload)}`);
+    return data;
+}
+
+// ALL CITY LINES
+export const allCityLinesApi = async (payload: AllCityLinesApiPayload): Promise<AllCityLinesApiResponse> => {
+    const data = await apiCall<AllCityLinesApiResponse>("get", `${allCityLinesApiPath}?${convertToQueryString(payload)}`);
+    return data;
+}
+
+// SELECT CITY
+export const selectCityApi = async (payload: SelectCityApiPayload): Promise<SelectCityApiResponse> => {
+    const data = await apiCall<SelectCityApiResponse, SelectCityApiPayload>("post", `${selectCityApiPath}`, payload);
+    return data;
+}
+
+// CURRECT CITY
+export const currectCityApi = async (payload: CurrectCityApiPayload): Promise<CurrectCityApiResponse> => {
+    const data = await apiCall<CurrectCityApiResponse>("post", `${currectCityApiPath}`, payload);
+    return data;
+}

package/src/services/apis/city/hooks.ts

@@ -0,0 +1,61 @@
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { AllCitiesApiPayload, CurrectCityApiPayload, CurrectCityApiResponse, SelectCityApiPayload, SelectCityApiResponse } from "./types";
+import { allCitiesApi, allCityLinesApi, currectCityApi, selectCityApi } from "./apis";
+import Toast from "react-native-toast-message";
+
+// ALL CITIES
+export const useFetchAllCities = (payload: AllCitiesApiPayload) => {
+    return useQuery({
+        queryKey: ["allCitiesApi", payload],
+        queryFn: () => allCitiesApi(payload)
+    })
+}
+
+// ALL CITIES
+export const useFetchAllCityLines = (payload: AllCitiesApiPayload) => {
+    return useQuery({
+        queryKey: ["allCityLinesApi", payload],
+        queryFn: () => allCityLinesApi(payload)
+    })
+}
+
+// SELECT CITY
+export const useMutateSelectCity = (response: (data: SelectCityApiResponse) => void) => {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (payload: SelectCityApiPayload) => selectCityApi(payload),
+        onSuccess: data => {
+            response(data);
+            if (data.status === 'success') {
+                queryClient.invalidateQueries({ queryKey: ["currectCityApi"] });
+                queryClient.invalidateQueries({ queryKey: ["loggedInUserApi"] });
+            } else {
+                Toast.show({
+                    type: "error",
+                    text1: data.message
+                });
+            }
+        }
+    })
+}
+
+// CURRECT CITY
+export const useFetchCurrectCity = (payload: CurrectCityApiPayload) => {
+    return useQuery({
+        queryKey: ["currectCityApi", payload],
+        queryFn: () => currectCityApi(payload)
+    })
+}
+
+export const useMutateCurrectCity = (onSuccess: (data: CurrectCityApiResponse) => void, onError: (data: CurrectCityApiResponse) => void) => {
+    return useMutation({
+        mutationFn: (payload: CurrectCityApiPayload) => currectCityApi(payload),
+        onSuccess: data => {
+            if (data.status === 'success') {
+                onSuccess(data);
+            } else {
+                onError(data);
+            }
+        }
+    })
+}