react-native-mytatva-rn-sdk 1.0.0 → 1.2.0

package/src/index.ios.js

@@ -17,9 +17,20 @@ import {
 } from 'react-native';
 import { EventRegister } from 'react-native-event-listeners';
 import { WebView } from 'react-native-webview';
-import DeviceInfo from 'react-native-device-info';
-import { getWebViewLink, httpClient } from './Services';
 import constants from './constants';
+import axios from 'axios';
+import {getEncryptedText, getDecryptedData} from './Services';
+
+import MainWebView from './MainWebView';
+import ProgressWebView from './ProgressWebView';
+import { SheetManager, SheetProvider } from 'react-native-actions-sheet';
+
+import '../src/Sheets';
+import { Provider } from 'react-redux';
+import { configureStore } from '@reduxjs/toolkit';
+import createSagaMiddleware from '@redux-saga/core';
+import rootReducer from './redux/slices';
+import rootSaga from './redux/sagas';
 
 const LINKING_ERROR =
   `The package 'react-native-mytatva-rn-sdk' doesn't seem to be linked. Make sure: \n\n` +
@@ -52,111 +63,40 @@ const unescapeHTML = (str) =>
     }
   });
 
-const visitEvent = 'visit-event';
+const mytatvaEvent = 'mytatva-event';
+
+const sagaMiddleware = createSagaMiddleware();
+const store = configureStore({
+  reducer: rootReducer,
+  middleware: (getDefaultMiddleware) => getDefaultMiddleware().concat(sagaMiddleware)
+});
+
+sagaMiddleware.run(rootSaga);
 
 const MyTatvaRnSdkView = ({
-  cpsid,
+  mobileNumber,
+  uuid,
   baseUrl,
   errorBaseUrl,
   token,
-  moduleName,
   environment,
-  magicLink,
-  isLoggingEnabled,
+  userMetaInfo,
+  clientSource,
+  moduleName,
+  navigation
 }) => {
   const [source, setSource] = useState('');
-  const [loading, setLoading] = useState(true);
-  useEffect(() => {
-    if (magicLink?.trim()?.length) {
-      setSource(magicLink);
-      setLoading(false);
-    } else {
-      const systemVersion = DeviceInfo.getSystemVersion();
-      const version = DeviceInfo.getVersion();
-      DeviceInfo.getUniqueId()
-        .then((uniqueId) =>
-          getWebViewLink(
-            baseUrl,
-            token,
-            cpsid,
-            'iPhone',
-            uniqueId,
-            version,
-            systemVersion,
-            environment
-          )
-        )
-        .then((res) => {
-          if (res.data?.errorMessage) {
-            const { errorMessage } = res.data;
-            const errorUrl = `${errorBaseUrl}/star-health?error=${errorMessage}`;
-            setSource(errorUrl);
-            if (res.data?.errorMessage === 'Please login again') {
-              EventRegister.emitEvent(visitEvent, {
-                message: 'unauthorized-wellness-access',
-                errorMessage: errorMessage,
-              });
-            }
-            if (res.data?.errorMessage.includes('External Server Error')) {
-              EventRegister.emitEvent('visit-event', {
-                message: 'external-server-error',
-                errorMessage: errorMessage,
-              });
-            }
-          } else if (res.data.message === 'success') {
-            const magicCode = res.data?.magicCode;
-            const responseReferenceId = res.data?.responseReferenceId;
-            let finalBaseUrl = '';
-            if (magicCode) {
-              if (environment.toUpperCase() === 'PROD') {
-                finalBaseUrl = constants.PROD_BASE_URL;
-              } else {
-                finalBaseUrl = constants.STAGE_BASE_URL;
-              }
-            }
-            if (finalBaseUrl && magicCode) {
-              let finalUrl = `${finalBaseUrl}=${magicCode}`;
-              if (moduleName?.trim()) {
-                finalUrl += `&tab=${moduleName}`;
-              }
+  const [loading, setLoading] = useState(false);
+  const [isError, setError] = useState(false);
 
-              if (
-                typeof responseReferenceId === 'string' &&
-                responseReferenceId.trim().length > 0
-              ) {
-                finalUrl += `&responseReferenceId=${responseReferenceId}`;
-              }
+  // useEffect(() => {
+  //   if ((baseUrl?.trim()?.length || 0) > 0) {
+  //     setSource(baseUrl);
+  //   }
+  // }, [
+  //   baseUrl,
 
-              setSource(finalUrl);
-            }
-          } else {
-            EventRegister.emitEvent('visit-event', {
-              message: 'generate-magic-link-failed',
-              errorMessage: `${res.data}`,
-            });
-          }
-        })
-        .catch((err) => {
-          console.log('getWebViewLink err', { err });
-          EventRegister.emitEvent('visit-event', {
-            message: 'generate-magic-link-failed',
-            errorMessage: `${err}`,
-          });
-        })
-        .finally(() => {
-          setLoading(false);
-        });
-    }
-  }, [
-    cpsid,
-    token,
-    baseUrl,
-    errorBaseUrl,
-    moduleName,
-    environment,
-    magicLink,
-    isLoggingEnabled,
-  ]);
+  // ]);
 
   const MyTatvaRnSdkViewManager = useMemo(
     () =>
@@ -173,134 +113,108 @@ const MyTatvaRnSdkView = ({
     []
   );
 
+  useEffect(() => {
+    if (!uuid && !mobileNumber) {
+      setTimeout(() => {
+        EventRegister.emitEvent('mytatva-event', {
+          message: 'unique-identifier',
+          errorMessage: 'contact number or patientId is required',
+        });
+      }, 1000)
+      setError(true)
+    } else {
+      authenticateSDK()
+      setError(false)
+    }
+  }, [uuid, mobileNumber])
+
   const webviewRef = useRef(null);
-  const [apiBaseUrl, setApiBaseUrl] = useState('');
-  const [authToken, setAuthToken] = useState('');
-  const [hasLoadedOnce, setHasLoadedOnce] = useState(false);
 
-  const callSyncApi = useCallback(
-    (data) =>
-      httpClient
-        .post(`${apiBaseUrl}/users/data-sync`, data, {
-          headers: {
-            Authorization: authToken,
-          },
-        })
-        .then((res) => console.log('callSyncData response,', res))
-        .catch((err) => console.log('callSyncData err,', { err })),
-    [apiBaseUrl, authToken]
-  );
+  const authenticateSDK = () => {
+    setLoading(true)
+    let baseUrl = environment.toUpperCase() === 'PROD' ? constants.PROD_BASE_URL : constants.STAGE_BASE_URL
+    const finalUrl = baseUrl + '/helper/authenticateClient';
+    const data = {
+      source : clientSource,
+      sourceKey : token
+    }
+    axios({
+      method: 'post',
+      url: finalUrl,
+      headers: {
+        'api-key': environment.toUpperCase() === 'PROD' ? constants.PROD_API_KEY : constants.STAGE_API_KEY,
+        'Content-Type': 'text/plain',
+      }, 
+      data: getEncryptedText(data, environment),
+    })
+    .then(async response => {
+      const parsedResponse = await JSON.parse(getDecryptedData(response?.data, environment)); 
+        if (parsedResponse?.data == 0) {
+          setError(true);
+            EventRegister.emitEvent('mytatva-event', {
+              message: 'unauthorized-client',
+              errorMessage: 'Unauthorized Access',
+        });
+      } else {
+        getSourceUrl();
+      }
+    })
+    .catch((error) => {
+        console.log("error", error)
+    }).finally(() => {
+      setLoading(false);
+    })
+  }
 
-  const callEmbellishApi = useCallback(
-    (data) =>
-      httpClient
-        .post(`${apiBaseUrl}/users/embellish-sync`, data, {
-          headers: {
-            Authorization: authToken,
-          },
-        })
-        .then((res) => console.log('callEmbellishApi response,', res))
-        .catch((err) => console.log('callEmbellishApi err,', { err })),
-    [apiBaseUrl, authToken]
-  );
 
   useEffect(() => {
     const apiManagerEmitter = new NativeEventEmitter(MyTatvaRnSdkViewManager);
     const subscription = apiManagerEmitter.addListener(
       'EventReminder',
       (reminder) => {
-        if (reminder?.callSyncData && reminder?.callSyncData?.length) {
-          callSyncApi(reminder?.callSyncData[0]);
-        }
-        if (reminder?.callEmbellishApi && reminder?.callEmbellishApi?.length) {
-          callEmbellishApi(reminder?.callEmbellishApi[0]);
-        }
+
       }
     );
     return () => {
       subscription.remove();
     };
-  }, [MyTatvaRnSdkViewManager, callEmbellishApi, callSyncApi]);
+  }, [MyTatvaRnSdkViewManager]);
+
+  const getSourceUrl = () => {
+    let finalUrl = ''
+    const params = {
+      uuid,
+      mobileNumber,
+      clientSource,
+      moduleName,
+      environment,
+      ...userMetaInfo
+    }
+    let baseUrl = environment.toUpperCase() === 'PROD' ? constants.PROD_BASE_URL : constants.STAGE_BASE_URL
+    if(baseUrl) {
+      finalUrl = baseUrl + '?data=' + encodeURIComponent(JSON.stringify(params));
+      setSource(finalUrl);
+    } else {
+      console.log("No baseUrl")
+    }
+ 
+  }
 
   const handleMessage = async (event) => {
     const data = JSON.parse(unescapeHTML(event.nativeEvent.data));
     const {
       method,
-      type,
-      frequency,
-      timestamp,
-      // eslint-disable-next-line no-shadow
-      apiBaseUrl,
-      authtoken,
-      googleFitLastSync,
-      gfHourlyLastSync,
       url,
     } = data;
-    console.log('handleMessage data is', data);
-    console.log(unescapeHTML(event.nativeEvent.data));
     switch (method) {
       case 'UPDATE_PLATFORM':
         webviewRef.current?.injectJavaScript('window.setSdkPlatform("IOS")');
         break;
-      case 'CONNECT_TO_GOOGLE_FIT':
-        if (DeviceInfo.getModel() === 'iPad') {
-          console.log('unsupportedHealthKitDevice triggered');
-          webviewRef.current?.injectJavaScript(
-            'window.unsupportedHealthKitDevice(true)'
-          );
-        } else {
-          MyTatvaRnSdkViewManager?.connectToAppleHealth((res) => {
-            if (res?.sleepTime || res?.numberOfSteps) {
-              webviewRef.current?.injectJavaScript(
-                `window.updateFitnessPermissions(true,${res?.numberOfSteps},${res?.sleepTime})`
-              );
-            } else {
-              webviewRef.current?.injectJavaScript(
-                'window.updateFitnessPermissions(true,0,0)'
-              );
-            }
-          });
-        }
-        break;
-      case 'GET_DATA_TO_GENERATE_GRAPH':
-        MyTatvaRnSdkViewManager?.renderGraph(
-          { type, frequency, timestamp },
-          (err, results) => {
-            if (err) {
-              console.log('error initializing Healthkit: ', err);
-              return;
-            }
-            if (results[0]) {
-              console.log('results initializing Healthkit: ', results[0]);
-              webviewRef.current?.injectJavaScript(`window.${results[0]}`);
-            }
-          }
-        );
-        break;
-      case 'UPDATE_API_BASE_URL':
-        if (!hasLoadedOnce) {
-          console.log('apiBaseUrl is,', apiBaseUrl);
-          setApiBaseUrl(apiBaseUrl);
-          setAuthToken(authtoken);
-          MyTatvaRnSdkViewManager?.updateApiUrl({
-            googleFitLastSync,
-            gfHourlyLastSync,
-          });
-          setHasLoadedOnce(true);
-        }
-        break;
-
       case 'OPEN_PDF':
         Linking.openURL(url);
         break;
       case 'CLOSE_VIEW':
         break;
-      case 'GET_LOCATION_PERMISSIONS':
-        webviewRef.current?.injectJavaScript(
-          'window.checkTheGpsPermission(true)'
-        );
-        break;
-
       default:
         break;
     }
@@ -309,27 +223,41 @@ const MyTatvaRnSdkView = ({
   const { height, width } = Dimensions.get('screen');
   return (
     // eslint-disable-next-line react-native/no-inline-styles
-    <SafeAreaView style={{ flex: 1, backgroundColor: 'white', height, width }}>
-      {loading ? (
-        <LoadingIndicator />
+    <SafeAreaView style={{ flex: 1, backgroundColor: 'white' }}>
+      <Provider store={store}>
+    <SheetProvider>
+      {moduleName === 'progress' ? (  
+        <ProgressWebView
+          token={token}
+          environment={environment}
+          source={source}
+          loading={loading}
+          isError={isError}
+          webviewRef={webviewRef}
+          runBeforeFirst={runBeforeFirst}
+          setCanGoBack={setCanGoBack}
+          mobileNumber={mobileNumber}
+          moduleName={moduleName}
+          uuid={uuid}
+          clientSource={clientSource}
+        />
       ) : (
-        <WebView
-          ref={webviewRef}
-          source={{ uri: source }}
-          style={styles.webView}
-          javascriptEnabled
-          onMessage={handleMessage}
-          onError={(errorMessage) => {
-            EventRegister.emitEvent(visitEvent, {
-              message: 'web-view-error',
-              errorMessage: errorMessage,
-            });
-            if (isLoggingEnabled) {
-              console.warn('Webview error: ', errorMessage);
-            }
-          }}
+        <MainWebView
+          token={token}
+          environment={environment}
+          source={source}
+          loading={loading}
+          isError={isError}
+          webviewRef={webviewRef}
+          handleMessage={handleMessage}
+          runBeforeFirst={runBeforeFirst}
+          setCanGoBack={setCanGoBack}
+          clientSource={clientSource}
+          moduleName={moduleName}
         />
       )}
+    </SheetProvider>
+    </Provider>
     </SafeAreaView>
   );
 };
@@ -345,11 +273,15 @@ const styles = StyleSheet.create({
 });
 
 MyTatvaRnSdkView.defaultProps = {
-  id: '',
+  mobileNumber: '',
+  uuid: '',
   token: '',
   baseUrl: '',
   errorBaseUrl: '',
-  moduleName: '',
+  environment: '',
+  metaInfo: {},
+  clientSource: '',
+  moduleName: ''
 };
 
 export default MyTatvaRnSdkView;

package/src/redux/Store.ts

@@ -0,0 +1,36 @@
+// // --------------- LIBRARIES ---------------
+import {configureStore} from '@reduxjs/toolkit';
+import createSagaMiddleware from '@redux-saga/core';
+import logger from 'redux-logger';
+
+// // --------------- ASSETS ---------------
+import rootReducer from './slices';
+import rootSaga from './sagas';
+import {TypedUseSelectorHook, useDispatch, useSelector} from 'react-redux';
+
+// Middlewares setup
+const sagaMiddleware = createSagaMiddleware();
+const middlewares = [];
+
+// if (__DEV__) {
+//   middlewares.push(sagaMiddleware);
+//   // middlewares.push(sagaMiddleware, logger); // With logger
+// } else {
+  middlewares.push(sagaMiddleware); // without logger
+// }
+
+export const Store = configureStore({
+  reducer: rootReducer,
+  middleware: middlewares
+});
+
+// Infer the `RootState` and `AppDispatch` types from the store itself
+export type RootState = ReturnType<typeof Store.getState>;
+// Inferred type: {posts: PostsState, comments: CommentsState, users: UsersState}
+export type AppDispatch = typeof Store.dispatch;
+
+export const useAppDispatch: () => AppDispatch = useDispatch;
+export const useAppSelector: TypedUseSelectorHook<RootState> = useSelector;
+// // PersistStore contains all the data from store ----->>>>>
+// export const Persistor = persistStore(Store);
+sagaMiddleware.run(rootSaga); // Run Saga

package/src/redux/hooks.ts

@@ -0,0 +1,6 @@
+// import { TypedUseSelectorHook, useDispatch, useSelector } from 'react-redux';
+// // import type { RootState, AppDispatch } from '../store/index';
+// // import
+
+// export const useAppDispatch = () => useDispatch<AppDispatch>();
+// export const useAppSelector: TypedUseSelectorHook<RootState> = useSelector; 

package/src/redux/sagas/AuthSaga.ts

@@ -0,0 +1,49 @@
+// --------------- LIBRARIES ---------------
+import {put, call, takeEvery, all} from 'redux-saga/effects';
+import {auth, common} from '../../types';
+import * as actions from '../slices';
+import api from '../../api';
+import constants from '../../constants/constants';
+
+
+const AuthenticateUserRequest = function* AuthenticateUserRequest({
+    payload: { resolve, reject, payload, environment },
+  }: {
+    payload: any;
+    environment: string;
+  }) {
+    try {
+      const response: common.ResponseGenerator = yield call(
+        api.auth.authenticateUser,
+        {
+            payload,
+            environment
+        }
+      );
+      if (Number(response.code) === -1) {
+        throw new Error("Session Expire");
+      } else if (Number(response.code) === 0) {
+        throw new Error(response.message);
+      }
+      yield put(actions.authenticateUserSuccess(response));
+      resolve(response);
+    } catch (error) {
+      yield put(
+        actions.authenticateUserError(
+          error instanceof Error
+            ? error?.message
+            : "Something went wrong"
+        )
+      );
+      reject(error);
+    }
+  };
+
+function* authSaga() {
+    yield all([
+        takeEvery(actions.authenticateUserRequest, AuthenticateUserRequest),
+      ]);
+  
+}
+
+export default authSaga;

package/src/redux/sagas/index.ts

@@ -0,0 +1,9 @@
+import {all} from 'redux-saga/effects';
+import AuthSaga from './AuthSaga';
+//Main Root Saga
+const rootSaga = function* rootSaga() {
+  yield all([
+    AuthSaga(),
+  ]);
+};
+export default rootSaga;

package/src/redux/slices/authSlice.ts

@@ -0,0 +1,81 @@
+// src/store/slices/authSlice.ts
+import { createSlice, PayloadAction } from "@reduxjs/toolkit";
+import { auth } from "../../types";
+
+// Initial state for the auth slice
+const initialState: auth.UsersStateType = {
+  clientSource: "default",
+  mode: "",
+  user: {
+    data: {} as auth.UserType,
+    isLoading: false,
+    errors: "",
+    platform: "ios",
+  },
+  isUserLoggedIn: false,
+};
+
+// Define the auth slice
+const authSlice = createSlice({
+  name: "auth",
+  initialState,
+  reducers: {
+    authenticateUserRequest: (
+      state: auth.UsersStateType,
+      action: PayloadAction<any>
+    ) => {
+      state.user.isLoading = true;
+      state.user.errors = "";
+    },
+    authenticateUserSuccess: (
+      state: auth.UsersStateType,
+      action: PayloadAction<any>
+    ) => {
+      state.user.isLoading = false;
+      state.user.data = action.payload.data;
+      // setUserAttributes(action.payload.data);
+      // localStorage.setItem(
+      //   LOCAL_STORAGE.AUTH_TOKEN,
+      //   action.payload.data?.token
+      // );
+      // localStorage.setItem(
+      //   LOCAL_STORAGE.USER_INFO,
+      //   JSON.stringify(action.payload.data)
+      // );
+      state.isUserLoggedIn = true;
+    },
+    authenticateUserError: (
+      state: auth.UsersStateType,
+      { payload: error }: PayloadAction<string>
+    ) => {
+      state.user.isLoading = false;
+      state.user.errors = error;
+    },
+    setClientSource: (
+      state: auth.UsersStateType,
+      action: PayloadAction<any>
+    ) => {
+      let clientSource =
+        action.payload ||
+        // localStorage.getItem(LOCAL_STORAGE.CLIENT_SOURCE) ||
+        "default";
+      state.clientSource = clientSource;
+    },
+    setMode: (state: auth.UsersStateType, action: PayloadAction<any>) => {
+      // let mode =
+      //   action.payload || localStorage.getItem(LOCAL_STORAGE.MODE) || "";
+      // state.mode = mode;
+    },
+  },
+});
+
+// Export actions and reducer
+export const {
+  authenticateUserRequest,
+  authenticateUserSuccess,
+  authenticateUserError,
+  setClientSource,
+  setMode,
+} = authSlice.actions;
+
+export default authSlice.reducer;

package/src/redux/slices/index.ts

@@ -0,0 +1,29 @@
+import {combineReducers} from 'redux';
+
+import authSlice from './authSlice';
+
+
+let appReducer = combineReducers({
+  Auth: authSlice,
+});
+
+// export all action
+export * from './authSlice';
+
+const rootReducer = (state: any, action: any) => {
+  if (action?.type === 'drawer/logoutUserSuccess') {
+    state = {
+      Auth: {
+        user: {
+          data: undefined,
+          isLoading: false,
+          errors: '',
+        },
+      },
+    };
+  }
+
+  return appReducer(state, action);
+};
+
+export default rootReducer;