oneticket-sdk-vi 1.0.0

package/src/services/apis/metro/providers/hooks.ts

@@ -0,0 +1,31 @@
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { getMetroProvidersApi, requestMetroProvidersApi } from "./apis";
+import Toast from "react-native-toast-message";
+import { GetMetroProvidersApiPayload, RequestMetroProvidersApiPayload, RequestMetroProvidersApiResponse } from "./types";
+
+// SIGN UP OTP SEND
+export const useMutateRequestMetroProviders = (response: (data: RequestMetroProvidersApiResponse) => void) => {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (payload: RequestMetroProvidersApiPayload) => requestMetroProvidersApi(payload),
+        onSuccess: data => {
+            response(data);
+            if (data.status === 'success') {
+                queryClient.invalidateQueries({ queryKey: ["getMetroProvidersApi"] });
+            } else {
+                Toast.show({
+                    type: "error",
+                    text1: data.message || 'Error fetching providers.'
+                });
+            }
+        }
+    })
+}
+
+// GET METRO APP PROVIDERS
+export const useFetchGetMetroProviders = (payload: GetMetroProvidersApiPayload) => {
+    return useQuery({
+        queryKey: ["getMetroProvidersApi", payload],
+        queryFn: () => getMetroProvidersApi(payload)
+    })
+}

package/src/services/apis/metro/providers/types.ts

@@ -0,0 +1,28 @@
+// REQUEST METRO PROVIDERS
+export type RequestMetroProvidersApiPayload = {
+    cityCode: string;
+};
+export type RequestMetroProvidersApiResponse = {
+    status: 'success' | 'error',
+    message: string;
+    transaction_id: string;
+};
+
+// GET METRO PROVIDERS
+export type GetMetroProvidersApiPayload = {
+    transaction_id: string;
+};
+export type GetMetroProvidersApiResponse = {
+    status: 'success' | 'error',
+    message: string;
+    providers: {
+        bpp_id: string;
+        bpp_uri: string;
+        metroImg: string;
+        name: string;
+        stops: {
+            name: string;
+            code: string;
+        }[];
+    }[];
+};

package/src/services/apis/metro/stations/apis.ts

@@ -0,0 +1,18 @@
+import { convertToQueryString } from "../../../../utils/queryString";
+import { apiCall } from "../../../apiCall";
+import { findNearestStationApiPath, getMetroStationsApiPath } from "../../../apiRoutes";
+import { FindNearestStationApiPayload, FindNearestStationApiResponse, GetMetroStationsApiPayload, GetMetroStationsApiResponse } from "./types";
+
+// REQUEST METRO PROVIDERS
+export const getMetroStationsApi = async (payload: GetMetroStationsApiPayload): Promise<GetMetroStationsApiResponse> => {
+    const data = await apiCall<GetMetroStationsApiResponse>("get", `${getMetroStationsApiPath}?${convertToQueryString(payload)}`);
+    return data;
+}
+
+// FIND NEAREST STATION
+export const findNearestStationApi = async (payload: FindNearestStationApiPayload): Promise<FindNearestStationApiResponse> => {
+    const data = await apiCall<FindNearestStationApiResponse, FindNearestStationApiPayload>("post", `${findNearestStationApiPath}`, payload);
+    return data;
+}
+
+

package/src/services/apis/metro/stations/hooks.ts

@@ -0,0 +1,27 @@
+import { useMutation, useQuery } from "@tanstack/react-query";
+import { FindNearestStationApiPayload, FindNearestStationApiResponse, GetMetroStationsApiPayload } from "./types";
+import { findNearestStationApi, getMetroStationsApi } from "./apis";
+
+// GET METRO STATIONS
+export const useFetchGetMetroStations = (payload: GetMetroStationsApiPayload) => {
+    return useQuery({
+        queryKey: ["getMetroStationsApi", payload],
+        queryFn: () => getMetroStationsApi(payload)
+    })
+}
+
+// FIND NEAREST STATION
+export const useMutateFindNearestStation = (onSuccess: (data: FindNearestStationApiResponse) => void, onError: (data: FindNearestStationApiResponse) => void) => {
+    return useMutation({
+        mutationFn: (payload: FindNearestStationApiPayload) => findNearestStationApi(payload),
+        onSuccess: (data) => {
+            if (data.status === "success") {
+                onSuccess(data)
+            } else {
+                onError(data)
+            }
+        },
+    })
+}
+
+

package/src/services/apis/metro/stations/types.ts

@@ -0,0 +1,34 @@
+// GET METRO STATIONS
+export type GetMetroStationsApiPayload = {
+    cityCode: string;
+    mapId?: string;
+}
+export type GetMetroStationsApiResponse = {
+    status: 'success' | 'error';
+    message: string;
+    is_active: boolean;
+    operatingHours: {
+        start: string,
+        end: string
+    },
+    stations: {
+        name: string;
+        lineColor: string[];
+    }[];
+}
+
+// FIND NEAREST STATION
+export type FindNearestStationApiPayload = {
+    cityCode: string;
+    latitude: number;
+    longitude: number;
+}
+export type FindNearestStationApiResponse = {
+    status: 'success' | 'error';
+    message: string;
+    station: {
+        station_name: string;
+        gps: string;
+        distanceInKm: number;
+    }
+}

package/src/services/apis/metro/status/apis.ts

@@ -0,0 +1,15 @@
+import { apiCall } from "../../../apiCall";
+import { getMetroTicketStatusApiPath, isQrActiveApiPath } from "../../../apiRoutes";
+import { GetMetroTicketStatusApiPayload, GetMetroTicketStatusApiResponse, isQrActiveApiPayload, isQrActiveApiResponse } from "./types";
+
+// GET METRO TICKET STATUS
+export const getMetroTicketStatusApi = async (payload: GetMetroTicketStatusApiPayload): Promise<GetMetroTicketStatusApiResponse> => {
+    const data = await apiCall<GetMetroTicketStatusApiResponse, GetMetroTicketStatusApiPayload>("post", `${getMetroTicketStatusApiPath}`, payload);
+    return data;
+}
+
+// IS QR ACTIVE STATUS
+export const isQrActiveApi = async (payload: isQrActiveApiPayload): Promise<isQrActiveApiResponse> => {
+    const data = await apiCall<isQrActiveApiResponse, isQrActiveApiPayload>("post", `${isQrActiveApiPath}`, payload);
+    return data;
+}

package/src/services/apis/metro/status/hooks.ts

@@ -0,0 +1,19 @@
+import { useQuery } from "@tanstack/react-query";
+import { GetMetroTicketStatusApiPayload, isQrActiveApiPayload } from "./types";
+import { getMetroTicketStatusApi, isQrActiveApi } from "./apis";
+
+// REQUEST METRO TICKET STATUS
+export const useFetchgetMetroTicketStatus = (payload: GetMetroTicketStatusApiPayload) => {
+    return useQuery({
+        queryKey: ["getMetroTicketStatusApi", payload],
+        queryFn: () => getMetroTicketStatusApi(payload)
+    })
+}
+
+// REQUEST QR ACTIVE STATUS
+export const useFetchisQrActive = (payload: isQrActiveApiPayload) => {
+    return useQuery({
+        queryKey: ["getMetroTicketStatusApi", payload],
+        queryFn: () => isQrActiveApi(payload)
+    })
+}

package/src/services/apis/metro/status/types.ts

@@ -0,0 +1,55 @@
+// REQUEST METRO STATUS TICKET
+export type GetMetroTicketStatusApiPayload = {
+    transaction_id: string;
+};
+export type GetMetroTicketStatusApiResponse = {
+    status: 'success' | 'error';
+    message: string;
+    result: {
+        _id: string;
+        status: string;
+        startStation: string;
+        destinationStation: string;
+        ticketCount: number;
+        totalPrice: number;
+        itemName: string;
+        routes?: ({
+            station_name: string;
+            type: string;
+            instructions: string;
+            lineColor: string;
+        } | string)[];
+        multipleProviders: boolean;
+        isCancellationAvilable: boolean;
+        cancellationCharges: number;
+        refundAmount: number;
+        createdAt: string;
+        billingDetails: {
+            name: string;
+            email: string;
+            phone: string;
+            status: string;
+        },
+        line: string;
+        tickets: {
+            _id: string;
+            transaction_id: string;
+            startStation: string;
+            destinationStation: string;
+            qrCodeToken: string;
+            validTill: string;
+            status: string;
+            ticketId: string;
+            lineColors: string[];
+        }[][];
+    }
+};
+
+// REQUEST QR ACTIVE STATUS
+export type isQrActiveApiPayload = {
+};
+export type isQrActiveApiResponse = {
+    status: 'success' | 'error';
+    message: string;
+    isActive: boolean;
+};

package/src/services/apis/metro/ticketInit/apis.ts

@@ -0,0 +1,9 @@
+import { apiCall } from "../../../apiCall";
+import { initMetroTicketV2ApiPath } from "../../../apiRoutes";
+import { InitMetroTicketV2ApiPayload, InitMetroTicketV2ApiResponse } from "./types";
+
+// REQUEST METRO INIT TICKET
+export const initMetroTicketV2Api = async (payload: InitMetroTicketV2ApiPayload): Promise<InitMetroTicketV2ApiResponse> => {
+    const data = await apiCall<InitMetroTicketV2ApiResponse, InitMetroTicketV2ApiPayload>("post", `${initMetroTicketV2ApiPath}`, payload);
+    return data;
+}

package/src/services/apis/metro/ticketInit/hooks.ts

@@ -0,0 +1,23 @@
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import Toast from "react-native-toast-message";
+import { InitMetroTicketV2ApiPayload, InitMetroTicketV2ApiResponse } from "./types";
+import { initMetroTicketV2Api } from "./apis";
+
+export const useMutateInitMetroTicketV2 = (response: (data: InitMetroTicketV2ApiResponse) => void) => {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (payload: InitMetroTicketV2ApiPayload) => initMetroTicketV2Api(payload),
+        onSuccess: data => {
+            response(data);
+            if (data.status === 'success') {
+                queryClient.invalidateQueries({ queryKey: ["getRecentTransactionsApi", "getAllTransactionsApi"] });
+            } else {
+                Toast.show({
+                    type: "error",
+                    text1: data.message || 'Init ticket fail.'
+                });
+            }
+        }
+    })
+}
+

package/src/services/apis/metro/ticketInit/types.ts

@@ -0,0 +1,25 @@
+// INIT TICKET V2
+export type InitMetroTicketV2ApiPayload = {
+    itemName: string;
+    startStation: string;
+    destinationStation: string;
+    cityCode: string;
+    providers: {
+        providerName: string;
+        itemId: string;
+        price: number;
+        providerId: string;
+        transaction_id: string;
+        bpp_id: string;
+        startStationName: string;
+        destinationStationName: string;
+        startStationCode: string;
+        destinationStationCode: string;
+    }[];
+    ticketCount: number;
+};
+export type InitMetroTicketV2ApiResponse = {
+    status: 'success' | 'error';
+    message: string;
+    transaction_id: string;
+};

package/src/services/apis/session/apis.ts

@@ -0,0 +1,15 @@
+import { apiCall } from "../../apiCall";
+import { endSessionApiPath, startSessionApiPath } from "../../apiRoutes";
+import { EndSessionApiPayload, EndSessionApiResponse, StartSessionApiPayload, StartSessionApiResponse } from "./types";
+
+// START SESSION
+export const startSessionApi = async (payload: StartSessionApiPayload): Promise<StartSessionApiResponse> => {
+    const data = await apiCall<StartSessionApiResponse, StartSessionApiPayload>("post", `${startSessionApiPath}`, payload);
+    return data;
+}
+
+// END SESSION
+export const endSessionApi = async (payload: EndSessionApiPayload): Promise<EndSessionApiResponse> => {
+    const data = await apiCall<EndSessionApiResponse, EndSessionApiPayload>("post", `${endSessionApiPath}`, payload);
+    return data;
+}

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

@@ -0,0 +1,42 @@
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { EndSessionApiPayload, EndSessionApiResponse, StartSessionApiPayload, StartSessionApiResponse } from "./types";
+import { endSessionApi, startSessionApi } from "./apis";
+import Toast from "react-native-toast-message";
+
+// START SESSION
+export const useMutateStartSession = (response: (data: StartSessionApiResponse) => void) => {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (payload: StartSessionApiPayload) => startSessionApi(payload),
+        onSuccess: data => {
+            response(data);
+            if (data.status === 'success') {
+                queryClient.invalidateQueries({ queryKey: [""] });
+            } else {
+                Toast.show({
+                    type: "error",
+                    text1: data.message
+                });
+            }
+        }
+    })
+}
+
+// END SESSION
+export const useMutateEndSession = (response: (data: EndSessionApiResponse) => void) => {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (payload: EndSessionApiPayload) => endSessionApi(payload),
+        onSuccess: data => {
+            response(data);
+            if (data.status === 'success') {
+                queryClient.invalidateQueries({ queryKey: [""] });
+            } else {
+                Toast.show({
+                    type: "error",
+                    text1: data.message
+                });
+            }
+        }
+    })
+}

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

@@ -0,0 +1,17 @@
+// START SESSION
+export type StartSessionApiPayload = {
+    sessionId: string;
+};
+export type StartSessionApiResponse = {
+    status: 'success' | 'error';
+    message: string;
+};
+
+// END SESSION
+export type EndSessionApiPayload = {
+    sessionId: string;
+};
+export type EndSessionApiResponse = {
+    status: 'success' | 'error';
+    message: string;
+};

package/src/services/apis/transaction/apis.ts

@@ -0,0 +1,17 @@
+import { delay } from "../../../utils/delayApis";
+import { convertToQueryString } from "../../../utils/queryString";
+import { apiCall } from "../../apiCall";
+import { getAllTransactionsApiPath, getRecentTransactionsApiPath } from "../../apiRoutes";
+import { GetAllTransactionsApiPayload, GetAllTransactionsApiResponse, GetRecentTransactionsApiPayload, GetRecentTransactionsApiResponse } from "./types";
+
+// GET ALL TRANSACTIONS
+export const getAllTransactionsApi = async (payload: GetAllTransactionsApiPayload): Promise<GetAllTransactionsApiResponse> => {
+    const data = await apiCall<GetAllTransactionsApiResponse, GetAllTransactionsApiPayload>("get", `${getAllTransactionsApiPath}?${convertToQueryString(payload)}`);
+    return data;
+}
+
+// GET RECENT TRANSACTIONS
+export const getRecentTransactionsApi = async (payload: GetRecentTransactionsApiPayload): Promise<GetRecentTransactionsApiResponse> => {
+    const data = await apiCall<GetRecentTransactionsApiResponse, GetRecentTransactionsApiPayload>("get", `${getRecentTransactionsApiPath}?${convertToQueryString(payload)}`);
+    return data;
+}

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

@@ -0,0 +1,29 @@
+import { useInfiniteQuery, useQuery } from "@tanstack/react-query"
+import { getAllTransactionsApi, getRecentTransactionsApi } from "./apis"
+import { GetAllTransactionsApiPayload, GetRecentTransactionsApiPayload } from "./types"
+
+export const useFetchGetAllTransactions = (payload: Omit<GetAllTransactionsApiPayload, "page" | "limit">) => {
+    return useInfiniteQuery({
+        queryKey: ["getAllTransactionsApi", payload],
+        queryFn: ({ pageParam }) => getAllTransactionsApi({ page: pageParam, limit: 10, ...payload }),
+        initialPageParam: 1,
+        getNextPageParam: lastPage => {
+            if (lastPage.nextPage) {
+                return lastPage.nextPage
+            }
+        }
+    })
+}
+
+export const useFetchGetRecentTransactions = (payload: Omit<GetRecentTransactionsApiPayload, "page" | "limit">) => {
+    return useInfiniteQuery({
+        queryKey: ["getRecentTransactionsApi", payload],
+        queryFn: ({ pageParam }) => getRecentTransactionsApi({ page: pageParam, limit: 10, ...payload }),
+        initialPageParam: 1,
+        getNextPageParam: lastPage => {
+            if (lastPage.nextPage) {
+                return lastPage.nextPage
+            }
+        }
+    })
+}

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

@@ -0,0 +1,42 @@
+// GET ALL TRANSACTIONS
+export type GetAllTransactionsApiPayload = {
+    status?: string;
+    cityCode?: string;
+    page: number;
+    limit: number;
+};
+export type GetAllTransactionsApiResponse = {
+    status: 'success' | 'error';
+    message: string;
+    nextPage: null | number;
+    transactions: {
+        city: any;
+        _id: string;
+        type: string;
+        flowType: string;
+        status: string;
+        startStation: string;
+        destinationStation: string;
+        ticketCount: number;
+        totalPrice: number;
+        updatedAt: string;
+        createdAt: string;
+    }[];
+};
+
+// GET RECENT TRANSACTIONS
+export type GetRecentTransactionsApiPayload = {
+    cityCode: string;
+    page: number;
+    limit: number;
+};
+export type GetRecentTransactionsApiResponse = {
+    status: 'success' | 'error';
+    message: string;
+    nextPage: null | number;
+    result: {
+        startStation: string;
+        destinationStation: string;
+        createdAt: string;
+    }[];
+};

package/src/services/apis/user/apis.ts

@@ -0,0 +1,9 @@
+import { apiCall } from "../../apiCall";
+import { updateUserApiPath } from "../../apiRoutes";
+import { UpdateUserApiPayload, UpdateUserApiResponse } from "./types";
+
+// UPDATE USER
+export const updateUserApi = async (payload: UpdateUserApiPayload): Promise<UpdateUserApiResponse> => {
+    const data = await apiCall<UpdateUserApiResponse, UpdateUserApiPayload>("post", `${updateUserApiPath}`, payload);
+    return data;
+}

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

@@ -0,0 +1,18 @@
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { UpdateUserApiPayload, UpdateUserApiResponse } from "./types";
+import Toast from "react-native-toast-message";
+import { updateUserApi } from "./apis";
+
+// UPDATE USER
+export const useMutateUpdateUser = (response: (data: UpdateUserApiResponse) => void) => {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (payload: UpdateUserApiPayload) => updateUserApi(payload),
+        onSuccess: data => {
+            response(data);
+            if (data.status === 'success') {
+                queryClient.invalidateQueries({ queryKey: ["loggedInUserApi"] });
+            }
+        }
+    })
+}

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

@@ -0,0 +1,10 @@
+// UPDATE USER
+export type UpdateUserApiPayload = {
+    name?: string;
+    email?: string;
+    gender?: string;
+};
+export type UpdateUserApiResponse = {
+    status: 'success' | 'error';
+    message: string;
+};

package/src/theme/ThemeProvider.tsx

@@ -0,0 +1,62 @@
+import React, { createContext, useContext, useState, useEffect, useMemo } from 'react';
+import { Appearance, ColorSchemeName } from 'react-native';
+import { lightTheme, darkTheme, AppTheme } from '../theme';
+
+type ThemeContextType = {
+    theme: AppTheme;
+    isDark: boolean;
+    scheme: ColorSchemeName;
+    setScheme: (scheme: 'light' | 'dark') => void;
+    toggleTheme: () => void;
+};
+
+export const ThemeContext = createContext<ThemeContextType>({
+    theme: lightTheme,
+    isDark: false,
+    scheme: 'light',
+    setScheme: () => { },
+    toggleTheme: () => { },
+});
+
+export const ThemeProvider: React.FC<{ children: React.ReactNode }> = ({ children }) => {
+    const colorScheme = Appearance.getColorScheme();
+    const [scheme, setScheme] = useState<ColorSchemeName>(colorScheme);
+    // const isDark = scheme === 'dark';
+    const isDark = false;
+
+    console.log('scheme', colorScheme)
+
+    // Memoize the theme to prevent unnecessary recalculations
+    const theme = useMemo(() => (isDark ? darkTheme : lightTheme), [isDark]);
+
+    useEffect(() => {
+        const subscription = Appearance.addChangeListener(({ colorScheme }) => {
+            setScheme(colorScheme);
+        });
+        return () => subscription.remove();
+    }, []);
+
+    const handleSetScheme = (newScheme: 'light' | 'dark') => {
+        setScheme(newScheme);
+    };
+
+    const toggleTheme = () => {
+        setScheme(prev => (prev === 'light' ? 'dark' : 'light'));
+    };
+
+    return (
+        <ThemeContext.Provider
+            value={{
+                theme,
+                isDark,
+                scheme,
+                setScheme: handleSetScheme,
+                toggleTheme,
+            }}
+        >
+            {children}
+        </ThemeContext.Provider>
+    );
+};
+
+export const useTheme = () => useContext(ThemeContext);

package/src/theme/ThemeToggle.tsx

@@ -0,0 +1,42 @@
+import React from 'react';
+import { TouchableOpacity, Text, StyleSheet } from 'react-native';
+import { useTheme } from './ThemeProvider';
+// import MaterialIcon from 'react-native-vector-icons/MaterialIcons';
+
+const ThemeToggle = () => {
+    const { isDark, toggleTheme, theme } = useTheme();
+
+    const styles = StyleSheet.create({
+        button: {
+            flexDirection: 'row',
+            alignItems: 'center',
+            padding: theme.spacing.s,
+            borderRadius: theme.roundness,
+            backgroundColor: theme.colors.surfaceVariant,
+        },
+        text: {
+            marginLeft: theme.spacing.s,
+            ...theme.typography.labelLarge,
+            color: theme.colors.text,
+        },
+    });
+
+    return (
+        <TouchableOpacity
+            style={styles.button}
+            onPress={toggleTheme}
+            activeOpacity={0.7}
+        >
+            {/* <MaterialIcon
+                name={isDark ? 'wb-sunny' : 'nights-stay'}
+                size={theme.icons.medium}
+                color={theme.colors.primary[500]}
+            /> */}
+            <Text style={styles.text}>
+                {isDark ? 'Switch to Light' : 'Switch to Dark'}
+            </Text>
+        </TouchableOpacity>
+    );
+};
+
+export default ThemeToggle;